pub fn serialize_structure_crate_input_create_backup_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBackupPlanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.backup_plan {
#[allow(unused_mut)]
let mut object_2 = object.key("BackupPlan").start_object();
crate::json_ser::serialize_structure_crate_model_backup_plan_input(&mut object_2, var_1)?;
object_2.finish();
}
if let Some(var_3) = &input.backup_plan_tags {
#[allow(unused_mut)]
let mut object_4 = object.key("BackupPlanTags").start_object();
for (key_5, value_6) in var_3 {
{
object_4.key(key_5.as_str()).string(value_6.as_str());
}
}
object_4.finish();
}
if let Some(var_7) = &input.creator_request_id {
object.key("CreatorRequestId").string(var_7.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_backup_selection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBackupSelectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_8) = &input.backup_selection {
#[allow(unused_mut)]
let mut object_9 = object.key("BackupSelection").start_object();
crate::json_ser::serialize_structure_crate_model_backup_selection(&mut object_9, var_8)?;
object_9.finish();
}
if let Some(var_10) = &input.creator_request_id {
object.key("CreatorRequestId").string(var_10.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_backup_vault_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBackupVaultInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_11) = &input.backup_vault_tags {
#[allow(unused_mut)]
let mut object_12 = object.key("BackupVaultTags").start_object();
for (key_13, value_14) in var_11 {
{
object_12.key(key_13.as_str()).string(value_14.as_str());
}
}
object_12.finish();
}
if let Some(var_15) = &input.creator_request_id {
object.key("CreatorRequestId").string(var_15.as_str());
}
if let Some(var_16) = &input.encryption_key_arn {
object.key("EncryptionKeyArn").string(var_16.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_framework_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFrameworkInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_17) = &input.framework_controls {
let mut array_18 = object.key("FrameworkControls").start_array();
for item_19 in var_17 {
{
#[allow(unused_mut)]
let mut object_20 = array_18.value().start_object();
crate::json_ser::serialize_structure_crate_model_framework_control(
&mut object_20,
item_19,
)?;
object_20.finish();
}
}
array_18.finish();
}
if let Some(var_21) = &input.framework_description {
object.key("FrameworkDescription").string(var_21.as_str());
}
if let Some(var_22) = &input.framework_name {
object.key("FrameworkName").string(var_22.as_str());
}
if let Some(var_23) = &input.framework_tags {
#[allow(unused_mut)]
let mut object_24 = object.key("FrameworkTags").start_object();
for (key_25, value_26) in var_23 {
{
object_24.key(key_25.as_str()).string(value_26.as_str());
}
}
object_24.finish();
}
if let Some(var_27) = &input.idempotency_token {
object.key("IdempotencyToken").string(var_27.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_legal_hold_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLegalHoldInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_28) = &input.description {
object.key("Description").string(var_28.as_str());
}
if let Some(var_29) = &input.idempotency_token {
object.key("IdempotencyToken").string(var_29.as_str());
}
if let Some(var_30) = &input.recovery_point_selection {
#[allow(unused_mut)]
let mut object_31 = object.key("RecoveryPointSelection").start_object();
crate::json_ser::serialize_structure_crate_model_recovery_point_selection(
&mut object_31,
var_30,
)?;
object_31.finish();
}
if let Some(var_32) = &input.tags {
#[allow(unused_mut)]
let mut object_33 = object.key("Tags").start_object();
for (key_34, value_35) in var_32 {
{
object_33.key(key_34.as_str()).string(value_35.as_str());
}
}
object_33.finish();
}
if let Some(var_36) = &input.title {
object.key("Title").string(var_36.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_report_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateReportPlanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_37) = &input.idempotency_token {
object.key("IdempotencyToken").string(var_37.as_str());
}
if let Some(var_38) = &input.report_delivery_channel {
#[allow(unused_mut)]
let mut object_39 = object.key("ReportDeliveryChannel").start_object();
crate::json_ser::serialize_structure_crate_model_report_delivery_channel(
&mut object_39,
var_38,
)?;
object_39.finish();
}
if let Some(var_40) = &input.report_plan_description {
object.key("ReportPlanDescription").string(var_40.as_str());
}
if let Some(var_41) = &input.report_plan_name {
object.key("ReportPlanName").string(var_41.as_str());
}
if let Some(var_42) = &input.report_plan_tags {
#[allow(unused_mut)]
let mut object_43 = object.key("ReportPlanTags").start_object();
for (key_44, value_45) in var_42 {
{
object_43.key(key_44.as_str()).string(value_45.as_str());
}
}
object_43.finish();
}
if let Some(var_46) = &input.report_setting {
#[allow(unused_mut)]
let mut object_47 = object.key("ReportSetting").start_object();
crate::json_ser::serialize_structure_crate_model_report_setting(&mut object_47, var_46)?;
object_47.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_backup_plan_from_json_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetBackupPlanFromJsonInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_48) = &input.backup_plan_template_json {
object.key("BackupPlanTemplateJson").string(var_48.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_backup_vault_access_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutBackupVaultAccessPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_49) = &input.policy {
object.key("Policy").string(var_49.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_backup_vault_lock_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutBackupVaultLockConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.changeable_for_days {
object.key("ChangeableForDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_50).into()),
);
}
if let Some(var_51) = &input.max_retention_days {
object.key("MaxRetentionDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_51).into()),
);
}
if let Some(var_52) = &input.min_retention_days {
object.key("MinRetentionDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_52).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_backup_vault_notifications_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutBackupVaultNotificationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_53) = &input.backup_vault_events {
let mut array_54 = object.key("BackupVaultEvents").start_array();
for item_55 in var_53 {
{
array_54.value().string(item_55.as_str());
}
}
array_54.finish();
}
if let Some(var_56) = &input.sns_topic_arn {
object.key("SNSTopicArn").string(var_56.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_backup_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartBackupJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_57) = &input.backup_options {
#[allow(unused_mut)]
let mut object_58 = object.key("BackupOptions").start_object();
for (key_59, value_60) in var_57 {
{
object_58.key(key_59.as_str()).string(value_60.as_str());
}
}
object_58.finish();
}
if let Some(var_61) = &input.backup_vault_name {
object.key("BackupVaultName").string(var_61.as_str());
}
if let Some(var_62) = &input.complete_window_minutes {
object.key("CompleteWindowMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_62).into()),
);
}
if let Some(var_63) = &input.iam_role_arn {
object.key("IamRoleArn").string(var_63.as_str());
}
if let Some(var_64) = &input.idempotency_token {
object.key("IdempotencyToken").string(var_64.as_str());
}
if let Some(var_65) = &input.lifecycle {
#[allow(unused_mut)]
let mut object_66 = object.key("Lifecycle").start_object();
crate::json_ser::serialize_structure_crate_model_lifecycle(&mut object_66, var_65)?;
object_66.finish();
}
if let Some(var_67) = &input.recovery_point_tags {
#[allow(unused_mut)]
let mut object_68 = object.key("RecoveryPointTags").start_object();
for (key_69, value_70) in var_67 {
{
object_68.key(key_69.as_str()).string(value_70.as_str());
}
}
object_68.finish();
}
if let Some(var_71) = &input.resource_arn {
object.key("ResourceArn").string(var_71.as_str());
}
if let Some(var_72) = &input.start_window_minutes {
object.key("StartWindowMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_72).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_start_copy_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartCopyJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_73) = &input.destination_backup_vault_arn {
object
.key("DestinationBackupVaultArn")
.string(var_73.as_str());
}
if let Some(var_74) = &input.iam_role_arn {
object.key("IamRoleArn").string(var_74.as_str());
}
if let Some(var_75) = &input.idempotency_token {
object.key("IdempotencyToken").string(var_75.as_str());
}
if let Some(var_76) = &input.lifecycle {
#[allow(unused_mut)]
let mut object_77 = object.key("Lifecycle").start_object();
crate::json_ser::serialize_structure_crate_model_lifecycle(&mut object_77, var_76)?;
object_77.finish();
}
if let Some(var_78) = &input.recovery_point_arn {
object.key("RecoveryPointArn").string(var_78.as_str());
}
if let Some(var_79) = &input.source_backup_vault_name {
object.key("SourceBackupVaultName").string(var_79.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_report_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartReportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_80) = &input.idempotency_token {
object.key("IdempotencyToken").string(var_80.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_restore_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartRestoreJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.iam_role_arn {
object.key("IamRoleArn").string(var_81.as_str());
}
if let Some(var_82) = &input.idempotency_token {
object.key("IdempotencyToken").string(var_82.as_str());
}
if let Some(var_83) = &input.metadata {
#[allow(unused_mut)]
let mut object_84 = object.key("Metadata").start_object();
for (key_85, value_86) in var_83 {
{
object_84.key(key_85.as_str()).string(value_86.as_str());
}
}
object_84.finish();
}
if let Some(var_87) = &input.recovery_point_arn {
object.key("RecoveryPointArn").string(var_87.as_str());
}
if let Some(var_88) = &input.resource_type {
object.key("ResourceType").string(var_88.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_89) = &input.tags {
#[allow(unused_mut)]
let mut object_90 = object.key("Tags").start_object();
for (key_91, value_92) in var_89 {
{
object_90.key(key_91.as_str()).string(value_92.as_str());
}
}
object_90.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_93) = &input.tag_key_list {
let mut array_94 = object.key("TagKeyList").start_array();
for item_95 in var_93 {
{
array_94.value().string(item_95.as_str());
}
}
array_94.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_backup_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBackupPlanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_96) = &input.backup_plan {
#[allow(unused_mut)]
let mut object_97 = object.key("BackupPlan").start_object();
crate::json_ser::serialize_structure_crate_model_backup_plan_input(&mut object_97, var_96)?;
object_97.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_framework_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFrameworkInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_98) = &input.framework_controls {
let mut array_99 = object.key("FrameworkControls").start_array();
for item_100 in var_98 {
{
#[allow(unused_mut)]
let mut object_101 = array_99.value().start_object();
crate::json_ser::serialize_structure_crate_model_framework_control(
&mut object_101,
item_100,
)?;
object_101.finish();
}
}
array_99.finish();
}
if let Some(var_102) = &input.framework_description {
object.key("FrameworkDescription").string(var_102.as_str());
}
if let Some(var_103) = &input.idempotency_token {
object.key("IdempotencyToken").string(var_103.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_global_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGlobalSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_104) = &input.global_settings {
#[allow(unused_mut)]
let mut object_105 = object.key("GlobalSettings").start_object();
for (key_106, value_107) in var_104 {
{
object_105.key(key_106.as_str()).string(value_107.as_str());
}
}
object_105.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_recovery_point_lifecycle_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRecoveryPointLifecycleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_108) = &input.lifecycle {
#[allow(unused_mut)]
let mut object_109 = object.key("Lifecycle").start_object();
crate::json_ser::serialize_structure_crate_model_lifecycle(&mut object_109, var_108)?;
object_109.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_region_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRegionSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_110) = &input.resource_type_management_preference {
#[allow(unused_mut)]
let mut object_111 = object
.key("ResourceTypeManagementPreference")
.start_object();
for (key_112, value_113) in var_110 {
{
object_111.key(key_112.as_str()).boolean(*value_113);
}
}
object_111.finish();
}
if let Some(var_114) = &input.resource_type_opt_in_preference {
#[allow(unused_mut)]
let mut object_115 = object.key("ResourceTypeOptInPreference").start_object();
for (key_116, value_117) in var_114 {
{
object_115.key(key_116.as_str()).boolean(*value_117);
}
}
object_115.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_report_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateReportPlanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_118) = &input.idempotency_token {
object.key("IdempotencyToken").string(var_118.as_str());
}
if let Some(var_119) = &input.report_delivery_channel {
#[allow(unused_mut)]
let mut object_120 = object.key("ReportDeliveryChannel").start_object();
crate::json_ser::serialize_structure_crate_model_report_delivery_channel(
&mut object_120,
var_119,
)?;
object_120.finish();
}
if let Some(var_121) = &input.report_plan_description {
object.key("ReportPlanDescription").string(var_121.as_str());
}
if let Some(var_122) = &input.report_setting {
#[allow(unused_mut)]
let mut object_123 = object.key("ReportSetting").start_object();
crate::json_ser::serialize_structure_crate_model_report_setting(&mut object_123, var_122)?;
object_123.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_backup_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BackupPlanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_124) = &input.backup_plan_name {
object.key("BackupPlanName").string(var_124.as_str());
}
if let Some(var_125) = &input.rules {
let mut array_126 = object.key("Rules").start_array();
for item_127 in var_125 {
{
#[allow(unused_mut)]
let mut object_128 = array_126.value().start_object();
crate::json_ser::serialize_structure_crate_model_backup_rule_input(
&mut object_128,
item_127,
)?;
object_128.finish();
}
}
array_126.finish();
}
if let Some(var_129) = &input.advanced_backup_settings {
let mut array_130 = object.key("AdvancedBackupSettings").start_array();
for item_131 in var_129 {
{
#[allow(unused_mut)]
let mut object_132 = array_130.value().start_object();
crate::json_ser::serialize_structure_crate_model_advanced_backup_setting(
&mut object_132,
item_131,
)?;
object_132.finish();
}
}
array_130.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_backup_selection(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BackupSelection,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_133) = &input.selection_name {
object.key("SelectionName").string(var_133.as_str());
}
if let Some(var_134) = &input.iam_role_arn {
object.key("IamRoleArn").string(var_134.as_str());
}
if let Some(var_135) = &input.resources {
let mut array_136 = object.key("Resources").start_array();
for item_137 in var_135 {
{
array_136.value().string(item_137.as_str());
}
}
array_136.finish();
}
if let Some(var_138) = &input.list_of_tags {
let mut array_139 = object.key("ListOfTags").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_condition(
&mut object_141,
item_140,
)?;
object_141.finish();
}
}
array_139.finish();
}
if let Some(var_142) = &input.not_resources {
let mut array_143 = object.key("NotResources").start_array();
for item_144 in var_142 {
{
array_143.value().string(item_144.as_str());
}
}
array_143.finish();
}
if let Some(var_145) = &input.conditions {
#[allow(unused_mut)]
let mut object_146 = object.key("Conditions").start_object();
crate::json_ser::serialize_structure_crate_model_conditions(&mut object_146, var_145)?;
object_146.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_framework_control(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FrameworkControl,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_147) = &input.control_name {
object.key("ControlName").string(var_147.as_str());
}
if let Some(var_148) = &input.control_input_parameters {
let mut array_149 = object.key("ControlInputParameters").start_array();
for item_150 in var_148 {
{
#[allow(unused_mut)]
let mut object_151 = array_149.value().start_object();
crate::json_ser::serialize_structure_crate_model_control_input_parameter(
&mut object_151,
item_150,
)?;
object_151.finish();
}
}
array_149.finish();
}
if let Some(var_152) = &input.control_scope {
#[allow(unused_mut)]
let mut object_153 = object.key("ControlScope").start_object();
crate::json_ser::serialize_structure_crate_model_control_scope(&mut object_153, var_152)?;
object_153.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_recovery_point_selection(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RecoveryPointSelection,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_154) = &input.vault_names {
let mut array_155 = object.key("VaultNames").start_array();
for item_156 in var_154 {
{
array_155.value().string(item_156.as_str());
}
}
array_155.finish();
}
if let Some(var_157) = &input.resource_identifiers {
let mut array_158 = object.key("ResourceIdentifiers").start_array();
for item_159 in var_157 {
{
array_158.value().string(item_159.as_str());
}
}
array_158.finish();
}
if let Some(var_160) = &input.date_range {
#[allow(unused_mut)]
let mut object_161 = object.key("DateRange").start_object();
crate::json_ser::serialize_structure_crate_model_date_range(&mut object_161, var_160)?;
object_161.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_report_delivery_channel(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReportDeliveryChannel,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_162) = &input.s3_bucket_name {
object.key("S3BucketName").string(var_162.as_str());
}
if let Some(var_163) = &input.s3_key_prefix {
object.key("S3KeyPrefix").string(var_163.as_str());
}
if let Some(var_164) = &input.formats {
let mut array_165 = object.key("Formats").start_array();
for item_166 in var_164 {
{
array_165.value().string(item_166.as_str());
}
}
array_165.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_report_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReportSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_167) = &input.report_template {
object.key("ReportTemplate").string(var_167.as_str());
}
if let Some(var_168) = &input.framework_arns {
let mut array_169 = object.key("FrameworkArns").start_array();
for item_170 in var_168 {
{
array_169.value().string(item_170.as_str());
}
}
array_169.finish();
}
if input.number_of_frameworks != 0 {
object.key("NumberOfFrameworks").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.number_of_frameworks).into()),
);
}
if let Some(var_171) = &input.accounts {
let mut array_172 = object.key("Accounts").start_array();
for item_173 in var_171 {
{
array_172.value().string(item_173.as_str());
}
}
array_172.finish();
}
if let Some(var_174) = &input.organization_units {
let mut array_175 = object.key("OrganizationUnits").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.regions {
let mut array_178 = object.key("Regions").start_array();
for item_179 in var_177 {
{
array_178.value().string(item_179.as_str());
}
}
array_178.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_lifecycle(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Lifecycle,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_180) = &input.move_to_cold_storage_after_days {
object.key("MoveToColdStorageAfterDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_180).into()),
);
}
if let Some(var_181) = &input.delete_after_days {
object.key("DeleteAfterDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_181).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_backup_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BackupRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_182) = &input.rule_name {
object.key("RuleName").string(var_182.as_str());
}
if let Some(var_183) = &input.target_backup_vault_name {
object.key("TargetBackupVaultName").string(var_183.as_str());
}
if let Some(var_184) = &input.schedule_expression {
object.key("ScheduleExpression").string(var_184.as_str());
}
if let Some(var_185) = &input.start_window_minutes {
object.key("StartWindowMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_185).into()),
);
}
if let Some(var_186) = &input.completion_window_minutes {
object.key("CompletionWindowMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_186).into()),
);
}
if let Some(var_187) = &input.lifecycle {
#[allow(unused_mut)]
let mut object_188 = object.key("Lifecycle").start_object();
crate::json_ser::serialize_structure_crate_model_lifecycle(&mut object_188, var_187)?;
object_188.finish();
}
if let Some(var_189) = &input.recovery_point_tags {
#[allow(unused_mut)]
let mut object_190 = object.key("RecoveryPointTags").start_object();
for (key_191, value_192) in var_189 {
{
object_190.key(key_191.as_str()).string(value_192.as_str());
}
}
object_190.finish();
}
if let Some(var_193) = &input.copy_actions {
let mut array_194 = object.key("CopyActions").start_array();
for item_195 in var_193 {
{
#[allow(unused_mut)]
let mut object_196 = array_194.value().start_object();
crate::json_ser::serialize_structure_crate_model_copy_action(
&mut object_196,
item_195,
)?;
object_196.finish();
}
}
array_194.finish();
}
if let Some(var_197) = &input.enable_continuous_backup {
object.key("EnableContinuousBackup").boolean(*var_197);
}
Ok(())
}
pub fn serialize_structure_crate_model_advanced_backup_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AdvancedBackupSetting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_198) = &input.resource_type {
object.key("ResourceType").string(var_198.as_str());
}
if let Some(var_199) = &input.backup_options {
#[allow(unused_mut)]
let mut object_200 = object.key("BackupOptions").start_object();
for (key_201, value_202) in var_199 {
{
object_200.key(key_201.as_str()).string(value_202.as_str());
}
}
object_200.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Condition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_203) = &input.condition_type {
object.key("ConditionType").string(var_203.as_str());
}
if let Some(var_204) = &input.condition_key {
object.key("ConditionKey").string(var_204.as_str());
}
if let Some(var_205) = &input.condition_value {
object.key("ConditionValue").string(var_205.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_conditions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Conditions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_206) = &input.string_equals {
let mut array_207 = object.key("StringEquals").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_condition_parameter(
&mut object_209,
item_208,
)?;
object_209.finish();
}
}
array_207.finish();
}
if let Some(var_210) = &input.string_not_equals {
let mut array_211 = object.key("StringNotEquals").start_array();
for item_212 in var_210 {
{
#[allow(unused_mut)]
let mut object_213 = array_211.value().start_object();
crate::json_ser::serialize_structure_crate_model_condition_parameter(
&mut object_213,
item_212,
)?;
object_213.finish();
}
}
array_211.finish();
}
if let Some(var_214) = &input.string_like {
let mut array_215 = object.key("StringLike").start_array();
for item_216 in var_214 {
{
#[allow(unused_mut)]
let mut object_217 = array_215.value().start_object();
crate::json_ser::serialize_structure_crate_model_condition_parameter(
&mut object_217,
item_216,
)?;
object_217.finish();
}
}
array_215.finish();
}
if let Some(var_218) = &input.string_not_like {
let mut array_219 = object.key("StringNotLike").start_array();
for item_220 in var_218 {
{
#[allow(unused_mut)]
let mut object_221 = array_219.value().start_object();
crate::json_ser::serialize_structure_crate_model_condition_parameter(
&mut object_221,
item_220,
)?;
object_221.finish();
}
}
array_219.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_control_input_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ControlInputParameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_222) = &input.parameter_name {
object.key("ParameterName").string(var_222.as_str());
}
if let Some(var_223) = &input.parameter_value {
object.key("ParameterValue").string(var_223.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_control_scope(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ControlScope,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_224) = &input.compliance_resource_ids {
let mut array_225 = object.key("ComplianceResourceIds").start_array();
for item_226 in var_224 {
{
array_225.value().string(item_226.as_str());
}
}
array_225.finish();
}
if let Some(var_227) = &input.compliance_resource_types {
let mut array_228 = object.key("ComplianceResourceTypes").start_array();
for item_229 in var_227 {
{
array_228.value().string(item_229.as_str());
}
}
array_228.finish();
}
if let Some(var_230) = &input.tags {
#[allow(unused_mut)]
let mut object_231 = object.key("Tags").start_object();
for (key_232, value_233) in var_230 {
{
object_231.key(key_232.as_str()).string(value_233.as_str());
}
}
object_231.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_date_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DateRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_234) = &input.from_date {
object
.key("FromDate")
.date_time(var_234, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_235) = &input.to_date {
object
.key("ToDate")
.date_time(var_235, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_copy_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CopyAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_236) = &input.lifecycle {
#[allow(unused_mut)]
let mut object_237 = object.key("Lifecycle").start_object();
crate::json_ser::serialize_structure_crate_model_lifecycle(&mut object_237, var_236)?;
object_237.finish();
}
if let Some(var_238) = &input.destination_backup_vault_arn {
object
.key("DestinationBackupVaultArn")
.string(var_238.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_condition_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConditionParameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_239) = &input.condition_key {
object.key("ConditionKey").string(var_239.as_str());
}
if let Some(var_240) = &input.condition_value {
object.key("ConditionValue").string(var_240.as_str());
}
Ok(())
}