pub fn serialize_structure_crate_input_create_backup_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBackupPlanInput,
) {
if let Some(var_1) = &input.backup_plan {
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 {
let mut object_4 = object.key("BackupPlanTags").start_object();
for (key_5, value_6) in var_3 {
{
object_4.key(key_5).string(value_6);
}
}
object_4.finish();
}
if let Some(var_7) = &input.creator_request_id {
object.key("CreatorRequestId").string(var_7);
}
}
pub fn serialize_structure_crate_input_create_backup_selection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBackupSelectionInput,
) {
if let Some(var_8) = &input.backup_selection {
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);
}
}
pub fn serialize_structure_crate_input_create_backup_vault_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBackupVaultInput,
) {
if let Some(var_11) = &input.backup_vault_tags {
let mut object_12 = object.key("BackupVaultTags").start_object();
for (key_13, value_14) in var_11 {
{
object_12.key(key_13).string(value_14);
}
}
object_12.finish();
}
if let Some(var_15) = &input.creator_request_id {
object.key("CreatorRequestId").string(var_15);
}
if let Some(var_16) = &input.encryption_key_arn {
object.key("EncryptionKeyArn").string(var_16);
}
}
pub fn serialize_structure_crate_input_create_framework_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFrameworkInput,
) {
if let Some(var_17) = &input.framework_controls {
let mut array_18 = object.key("FrameworkControls").start_array();
for item_19 in var_17 {
{
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);
}
if let Some(var_22) = &input.framework_name {
object.key("FrameworkName").string(var_22);
}
if let Some(var_23) = &input.framework_tags {
let mut object_24 = object.key("FrameworkTags").start_object();
for (key_25, value_26) in var_23 {
{
object_24.key(key_25).string(value_26);
}
}
object_24.finish();
}
if let Some(var_27) = &input.idempotency_token {
object.key("IdempotencyToken").string(var_27);
}
}
pub fn serialize_structure_crate_input_create_report_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateReportPlanInput,
) {
if let Some(var_28) = &input.idempotency_token {
object.key("IdempotencyToken").string(var_28);
}
if let Some(var_29) = &input.report_delivery_channel {
let mut object_30 = object.key("ReportDeliveryChannel").start_object();
crate::json_ser::serialize_structure_crate_model_report_delivery_channel(
&mut object_30,
var_29,
);
object_30.finish();
}
if let Some(var_31) = &input.report_plan_description {
object.key("ReportPlanDescription").string(var_31);
}
if let Some(var_32) = &input.report_plan_name {
object.key("ReportPlanName").string(var_32);
}
if let Some(var_33) = &input.report_plan_tags {
let mut object_34 = object.key("ReportPlanTags").start_object();
for (key_35, value_36) in var_33 {
{
object_34.key(key_35).string(value_36);
}
}
object_34.finish();
}
if let Some(var_37) = &input.report_setting {
let mut object_38 = object.key("ReportSetting").start_object();
crate::json_ser::serialize_structure_crate_model_report_setting(&mut object_38, var_37);
object_38.finish();
}
}
pub fn serialize_structure_crate_input_get_backup_plan_from_json_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetBackupPlanFromJsonInput,
) {
if let Some(var_39) = &input.backup_plan_template_json {
object.key("BackupPlanTemplateJson").string(var_39);
}
}
pub fn serialize_structure_crate_input_put_backup_vault_access_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutBackupVaultAccessPolicyInput,
) {
if let Some(var_40) = &input.policy {
object.key("Policy").string(var_40);
}
}
pub fn serialize_structure_crate_input_put_backup_vault_lock_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutBackupVaultLockConfigurationInput,
) {
if let Some(var_41) = &input.changeable_for_days {
object.key("ChangeableForDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_41).into()),
);
}
if let Some(var_42) = &input.max_retention_days {
object.key("MaxRetentionDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_42).into()),
);
}
if let Some(var_43) = &input.min_retention_days {
object.key("MinRetentionDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_43).into()),
);
}
}
pub fn serialize_structure_crate_input_put_backup_vault_notifications_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutBackupVaultNotificationsInput,
) {
if let Some(var_44) = &input.backup_vault_events {
let mut array_45 = object.key("BackupVaultEvents").start_array();
for item_46 in var_44 {
{
array_45.value().string(item_46.as_str());
}
}
array_45.finish();
}
if let Some(var_47) = &input.sns_topic_arn {
object.key("SNSTopicArn").string(var_47);
}
}
pub fn serialize_structure_crate_input_start_backup_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartBackupJobInput,
) {
if let Some(var_48) = &input.backup_options {
let mut object_49 = object.key("BackupOptions").start_object();
for (key_50, value_51) in var_48 {
{
object_49.key(key_50).string(value_51);
}
}
object_49.finish();
}
if let Some(var_52) = &input.backup_vault_name {
object.key("BackupVaultName").string(var_52);
}
if let Some(var_53) = &input.complete_window_minutes {
object.key("CompleteWindowMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_53).into()),
);
}
if let Some(var_54) = &input.iam_role_arn {
object.key("IamRoleArn").string(var_54);
}
if let Some(var_55) = &input.idempotency_token {
object.key("IdempotencyToken").string(var_55);
}
if let Some(var_56) = &input.lifecycle {
let mut object_57 = object.key("Lifecycle").start_object();
crate::json_ser::serialize_structure_crate_model_lifecycle(&mut object_57, var_56);
object_57.finish();
}
if let Some(var_58) = &input.recovery_point_tags {
let mut object_59 = object.key("RecoveryPointTags").start_object();
for (key_60, value_61) in var_58 {
{
object_59.key(key_60).string(value_61);
}
}
object_59.finish();
}
if let Some(var_62) = &input.resource_arn {
object.key("ResourceArn").string(var_62);
}
if let Some(var_63) = &input.start_window_minutes {
object.key("StartWindowMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_63).into()),
);
}
}
pub fn serialize_structure_crate_input_start_copy_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartCopyJobInput,
) {
if let Some(var_64) = &input.destination_backup_vault_arn {
object.key("DestinationBackupVaultArn").string(var_64);
}
if let Some(var_65) = &input.iam_role_arn {
object.key("IamRoleArn").string(var_65);
}
if let Some(var_66) = &input.idempotency_token {
object.key("IdempotencyToken").string(var_66);
}
if let Some(var_67) = &input.lifecycle {
let mut object_68 = object.key("Lifecycle").start_object();
crate::json_ser::serialize_structure_crate_model_lifecycle(&mut object_68, var_67);
object_68.finish();
}
if let Some(var_69) = &input.recovery_point_arn {
object.key("RecoveryPointArn").string(var_69);
}
if let Some(var_70) = &input.source_backup_vault_name {
object.key("SourceBackupVaultName").string(var_70);
}
}
pub fn serialize_structure_crate_input_start_report_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartReportJobInput,
) {
if let Some(var_71) = &input.idempotency_token {
object.key("IdempotencyToken").string(var_71);
}
}
pub fn serialize_structure_crate_input_start_restore_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartRestoreJobInput,
) {
if let Some(var_72) = &input.iam_role_arn {
object.key("IamRoleArn").string(var_72);
}
if let Some(var_73) = &input.idempotency_token {
object.key("IdempotencyToken").string(var_73);
}
if let Some(var_74) = &input.metadata {
let mut object_75 = object.key("Metadata").start_object();
for (key_76, value_77) in var_74 {
{
object_75.key(key_76).string(value_77);
}
}
object_75.finish();
}
if let Some(var_78) = &input.recovery_point_arn {
object.key("RecoveryPointArn").string(var_78);
}
if let Some(var_79) = &input.resource_type {
object.key("ResourceType").string(var_79);
}
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) {
if let Some(var_80) = &input.tags {
let mut object_81 = object.key("Tags").start_object();
for (key_82, value_83) in var_80 {
{
object_81.key(key_82).string(value_83);
}
}
object_81.finish();
}
}
pub fn serialize_structure_crate_input_untag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UntagResourceInput,
) {
if let Some(var_84) = &input.tag_key_list {
let mut array_85 = object.key("TagKeyList").start_array();
for item_86 in var_84 {
{
array_85.value().string(item_86);
}
}
array_85.finish();
}
}
pub fn serialize_structure_crate_input_update_backup_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBackupPlanInput,
) {
if let Some(var_87) = &input.backup_plan {
let mut object_88 = object.key("BackupPlan").start_object();
crate::json_ser::serialize_structure_crate_model_backup_plan_input(&mut object_88, var_87);
object_88.finish();
}
}
pub fn serialize_structure_crate_input_update_framework_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFrameworkInput,
) {
if let Some(var_89) = &input.framework_controls {
let mut array_90 = object.key("FrameworkControls").start_array();
for item_91 in var_89 {
{
let mut object_92 = array_90.value().start_object();
crate::json_ser::serialize_structure_crate_model_framework_control(
&mut object_92,
item_91,
);
object_92.finish();
}
}
array_90.finish();
}
if let Some(var_93) = &input.framework_description {
object.key("FrameworkDescription").string(var_93);
}
if let Some(var_94) = &input.idempotency_token {
object.key("IdempotencyToken").string(var_94);
}
}
pub fn serialize_structure_crate_input_update_global_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGlobalSettingsInput,
) {
if let Some(var_95) = &input.global_settings {
let mut object_96 = object.key("GlobalSettings").start_object();
for (key_97, value_98) in var_95 {
{
object_96.key(key_97).string(value_98);
}
}
object_96.finish();
}
}
pub fn serialize_structure_crate_input_update_recovery_point_lifecycle_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRecoveryPointLifecycleInput,
) {
if let Some(var_99) = &input.lifecycle {
let mut object_100 = object.key("Lifecycle").start_object();
crate::json_ser::serialize_structure_crate_model_lifecycle(&mut object_100, var_99);
object_100.finish();
}
}
pub fn serialize_structure_crate_input_update_region_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRegionSettingsInput,
) {
if let Some(var_101) = &input.resource_type_opt_in_preference {
let mut object_102 = object.key("ResourceTypeOptInPreference").start_object();
for (key_103, value_104) in var_101 {
{
object_102.key(key_103).boolean(*value_104);
}
}
object_102.finish();
}
}
pub fn serialize_structure_crate_input_update_report_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateReportPlanInput,
) {
if let Some(var_105) = &input.idempotency_token {
object.key("IdempotencyToken").string(var_105);
}
if let Some(var_106) = &input.report_delivery_channel {
let mut object_107 = object.key("ReportDeliveryChannel").start_object();
crate::json_ser::serialize_structure_crate_model_report_delivery_channel(
&mut object_107,
var_106,
);
object_107.finish();
}
if let Some(var_108) = &input.report_plan_description {
object.key("ReportPlanDescription").string(var_108);
}
if let Some(var_109) = &input.report_setting {
let mut object_110 = object.key("ReportSetting").start_object();
crate::json_ser::serialize_structure_crate_model_report_setting(&mut object_110, var_109);
object_110.finish();
}
}
pub fn serialize_structure_crate_model_backup_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BackupPlanInput,
) {
if let Some(var_111) = &input.backup_plan_name {
object.key("BackupPlanName").string(var_111);
}
if let Some(var_112) = &input.rules {
let mut array_113 = object.key("Rules").start_array();
for item_114 in var_112 {
{
let mut object_115 = array_113.value().start_object();
crate::json_ser::serialize_structure_crate_model_backup_rule_input(
&mut object_115,
item_114,
);
object_115.finish();
}
}
array_113.finish();
}
if let Some(var_116) = &input.advanced_backup_settings {
let mut array_117 = object.key("AdvancedBackupSettings").start_array();
for item_118 in var_116 {
{
let mut object_119 = array_117.value().start_object();
crate::json_ser::serialize_structure_crate_model_advanced_backup_setting(
&mut object_119,
item_118,
);
object_119.finish();
}
}
array_117.finish();
}
}
pub fn serialize_structure_crate_model_backup_selection(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BackupSelection,
) {
if let Some(var_120) = &input.selection_name {
object.key("SelectionName").string(var_120);
}
if let Some(var_121) = &input.iam_role_arn {
object.key("IamRoleArn").string(var_121);
}
if let Some(var_122) = &input.resources {
let mut array_123 = object.key("Resources").start_array();
for item_124 in var_122 {
{
array_123.value().string(item_124);
}
}
array_123.finish();
}
if let Some(var_125) = &input.list_of_tags {
let mut array_126 = object.key("ListOfTags").start_array();
for item_127 in var_125 {
{
let mut object_128 = array_126.value().start_object();
crate::json_ser::serialize_structure_crate_model_condition(
&mut object_128,
item_127,
);
object_128.finish();
}
}
array_126.finish();
}
}
pub fn serialize_structure_crate_model_framework_control(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FrameworkControl,
) {
if let Some(var_129) = &input.control_name {
object.key("ControlName").string(var_129);
}
if let Some(var_130) = &input.control_input_parameters {
let mut array_131 = object.key("ControlInputParameters").start_array();
for item_132 in var_130 {
{
let mut object_133 = array_131.value().start_object();
crate::json_ser::serialize_structure_crate_model_control_input_parameter(
&mut object_133,
item_132,
);
object_133.finish();
}
}
array_131.finish();
}
if let Some(var_134) = &input.control_scope {
let mut object_135 = object.key("ControlScope").start_object();
crate::json_ser::serialize_structure_crate_model_control_scope(&mut object_135, var_134);
object_135.finish();
}
}
pub fn serialize_structure_crate_model_report_delivery_channel(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReportDeliveryChannel,
) {
if let Some(var_136) = &input.s3_bucket_name {
object.key("S3BucketName").string(var_136);
}
if let Some(var_137) = &input.s3_key_prefix {
object.key("S3KeyPrefix").string(var_137);
}
if let Some(var_138) = &input.formats {
let mut array_139 = object.key("Formats").start_array();
for item_140 in var_138 {
{
array_139.value().string(item_140);
}
}
array_139.finish();
}
}
pub fn serialize_structure_crate_model_report_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReportSetting,
) {
if let Some(var_141) = &input.report_template {
object.key("ReportTemplate").string(var_141);
}
if let Some(var_142) = &input.framework_arns {
let mut array_143 = object.key("FrameworkArns").start_array();
for item_144 in var_142 {
{
array_143.value().string(item_144);
}
}
array_143.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()),
);
}
}
pub fn serialize_structure_crate_model_lifecycle(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Lifecycle,
) {
if let Some(var_145) = &input.move_to_cold_storage_after_days {
object.key("MoveToColdStorageAfterDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_145).into()),
);
}
if let Some(var_146) = &input.delete_after_days {
object.key("DeleteAfterDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_146).into()),
);
}
}
pub fn serialize_structure_crate_model_backup_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BackupRuleInput,
) {
if let Some(var_147) = &input.rule_name {
object.key("RuleName").string(var_147);
}
if let Some(var_148) = &input.target_backup_vault_name {
object.key("TargetBackupVaultName").string(var_148);
}
if let Some(var_149) = &input.schedule_expression {
object.key("ScheduleExpression").string(var_149);
}
if let Some(var_150) = &input.start_window_minutes {
object.key("StartWindowMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_150).into()),
);
}
if let Some(var_151) = &input.completion_window_minutes {
object.key("CompletionWindowMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_151).into()),
);
}
if let Some(var_152) = &input.lifecycle {
let mut object_153 = object.key("Lifecycle").start_object();
crate::json_ser::serialize_structure_crate_model_lifecycle(&mut object_153, var_152);
object_153.finish();
}
if let Some(var_154) = &input.recovery_point_tags {
let mut object_155 = object.key("RecoveryPointTags").start_object();
for (key_156, value_157) in var_154 {
{
object_155.key(key_156).string(value_157);
}
}
object_155.finish();
}
if let Some(var_158) = &input.copy_actions {
let mut array_159 = object.key("CopyActions").start_array();
for item_160 in var_158 {
{
let mut object_161 = array_159.value().start_object();
crate::json_ser::serialize_structure_crate_model_copy_action(
&mut object_161,
item_160,
);
object_161.finish();
}
}
array_159.finish();
}
if let Some(var_162) = &input.enable_continuous_backup {
object.key("EnableContinuousBackup").boolean(*var_162);
}
}
pub fn serialize_structure_crate_model_advanced_backup_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AdvancedBackupSetting,
) {
if let Some(var_163) = &input.resource_type {
object.key("ResourceType").string(var_163);
}
if let Some(var_164) = &input.backup_options {
let mut object_165 = object.key("BackupOptions").start_object();
for (key_166, value_167) in var_164 {
{
object_165.key(key_166).string(value_167);
}
}
object_165.finish();
}
}
pub fn serialize_structure_crate_model_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Condition,
) {
if let Some(var_168) = &input.condition_type {
object.key("ConditionType").string(var_168.as_str());
}
if let Some(var_169) = &input.condition_key {
object.key("ConditionKey").string(var_169);
}
if let Some(var_170) = &input.condition_value {
object.key("ConditionValue").string(var_170);
}
}
pub fn serialize_structure_crate_model_control_input_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ControlInputParameter,
) {
if let Some(var_171) = &input.parameter_name {
object.key("ParameterName").string(var_171);
}
if let Some(var_172) = &input.parameter_value {
object.key("ParameterValue").string(var_172);
}
}
pub fn serialize_structure_crate_model_control_scope(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ControlScope,
) {
if let Some(var_173) = &input.compliance_resource_ids {
let mut array_174 = object.key("ComplianceResourceIds").start_array();
for item_175 in var_173 {
{
array_174.value().string(item_175);
}
}
array_174.finish();
}
if let Some(var_176) = &input.compliance_resource_types {
let mut array_177 = object.key("ComplianceResourceTypes").start_array();
for item_178 in var_176 {
{
array_177.value().string(item_178);
}
}
array_177.finish();
}
if let Some(var_179) = &input.tags {
let mut object_180 = object.key("Tags").start_object();
for (key_181, value_182) in var_179 {
{
object_180.key(key_181).string(value_182);
}
}
object_180.finish();
}
}
pub fn serialize_structure_crate_model_copy_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CopyAction,
) {
if let Some(var_183) = &input.lifecycle {
let mut object_184 = object.key("Lifecycle").start_object();
crate::json_ser::serialize_structure_crate_model_lifecycle(&mut object_184, var_183);
object_184.finish();
}
if let Some(var_185) = &input.destination_backup_vault_arn {
object.key("DestinationBackupVaultArn").string(var_185);
}
}