pub fn serialize_operation_crate_operation_add_role_to_db_cluster(
input: &crate::input::AddRoleToDbClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AddRoleToDBCluster", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1 = writer.prefix("DBClusterIdentifier");
if let Some(var_2) = &input.db_cluster_identifier {
scope_1.string(var_2);
}
#[allow(unused_mut)]
let mut scope_3 = writer.prefix("RoleArn");
if let Some(var_4) = &input.role_arn {
scope_3.string(var_4);
}
#[allow(unused_mut)]
let mut scope_5 = writer.prefix("FeatureName");
if let Some(var_6) = &input.feature_name {
scope_5.string(var_6);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_add_role_to_db_instance(
input: &crate::input::AddRoleToDbInstanceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AddRoleToDBInstance", "2014-10-31");
#[allow(unused_mut)]
let mut scope_7 = writer.prefix("DBInstanceIdentifier");
if let Some(var_8) = &input.db_instance_identifier {
scope_7.string(var_8);
}
#[allow(unused_mut)]
let mut scope_9 = writer.prefix("RoleArn");
if let Some(var_10) = &input.role_arn {
scope_9.string(var_10);
}
#[allow(unused_mut)]
let mut scope_11 = writer.prefix("FeatureName");
if let Some(var_12) = &input.feature_name {
scope_11.string(var_12);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_add_source_identifier_to_subscription(
input: &crate::input::AddSourceIdentifierToSubscriptionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"AddSourceIdentifierToSubscription",
"2014-10-31",
);
#[allow(unused_mut)]
let mut scope_13 = writer.prefix("SubscriptionName");
if let Some(var_14) = &input.subscription_name {
scope_13.string(var_14);
}
#[allow(unused_mut)]
let mut scope_15 = writer.prefix("SourceIdentifier");
if let Some(var_16) = &input.source_identifier {
scope_15.string(var_16);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_add_tags_to_resource(
input: &crate::input::AddTagsToResourceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AddTagsToResource", "2014-10-31");
#[allow(unused_mut)]
let mut scope_17 = writer.prefix("ResourceName");
if let Some(var_18) = &input.resource_name {
scope_17.string(var_18);
}
#[allow(unused_mut)]
let mut scope_19 = writer.prefix("Tags");
if let Some(var_20) = &input.tags {
let mut list_22 = scope_19.start_list(false, Some("Tag"));
for item_21 in var_20 {
#[allow(unused_mut)]
let mut entry_23 = list_22.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_23, item_21)?;
}
list_22.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_apply_pending_maintenance_action(
input: &crate::input::ApplyPendingMaintenanceActionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ApplyPendingMaintenanceAction", "2014-10-31");
#[allow(unused_mut)]
let mut scope_24 = writer.prefix("ResourceIdentifier");
if let Some(var_25) = &input.resource_identifier {
scope_24.string(var_25);
}
#[allow(unused_mut)]
let mut scope_26 = writer.prefix("ApplyAction");
if let Some(var_27) = &input.apply_action {
scope_26.string(var_27);
}
#[allow(unused_mut)]
let mut scope_28 = writer.prefix("OptInType");
if let Some(var_29) = &input.opt_in_type {
scope_28.string(var_29);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_authorize_db_security_group_ingress(
input: &crate::input::AuthorizeDbSecurityGroupIngressInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"AuthorizeDBSecurityGroupIngress",
"2014-10-31",
);
#[allow(unused_mut)]
let mut scope_30 = writer.prefix("DBSecurityGroupName");
if let Some(var_31) = &input.db_security_group_name {
scope_30.string(var_31);
}
#[allow(unused_mut)]
let mut scope_32 = writer.prefix("CIDRIP");
if let Some(var_33) = &input.cidrip {
scope_32.string(var_33);
}
#[allow(unused_mut)]
let mut scope_34 = writer.prefix("EC2SecurityGroupName");
if let Some(var_35) = &input.ec2_security_group_name {
scope_34.string(var_35);
}
#[allow(unused_mut)]
let mut scope_36 = writer.prefix("EC2SecurityGroupId");
if let Some(var_37) = &input.ec2_security_group_id {
scope_36.string(var_37);
}
#[allow(unused_mut)]
let mut scope_38 = writer.prefix("EC2SecurityGroupOwnerId");
if let Some(var_39) = &input.ec2_security_group_owner_id {
scope_38.string(var_39);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_backtrack_db_cluster(
input: &crate::input::BacktrackDbClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "BacktrackDBCluster", "2014-10-31");
#[allow(unused_mut)]
let mut scope_40 = writer.prefix("DBClusterIdentifier");
if let Some(var_41) = &input.db_cluster_identifier {
scope_40.string(var_41);
}
#[allow(unused_mut)]
let mut scope_42 = writer.prefix("BacktrackTo");
if let Some(var_43) = &input.backtrack_to {
scope_42.date_time(var_43, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_44 = writer.prefix("Force");
if let Some(var_45) = &input.force {
scope_44.boolean(*var_45);
}
#[allow(unused_mut)]
let mut scope_46 = writer.prefix("UseEarliestTimeOnPointInTimeUnavailable");
if let Some(var_47) = &input.use_earliest_time_on_point_in_time_unavailable {
scope_46.boolean(*var_47);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_cancel_export_task(
input: &crate::input::CancelExportTaskInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CancelExportTask", "2014-10-31");
#[allow(unused_mut)]
let mut scope_48 = writer.prefix("ExportTaskIdentifier");
if let Some(var_49) = &input.export_task_identifier {
scope_48.string(var_49);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_copy_db_cluster_parameter_group(
input: &crate::input::CopyDbClusterParameterGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CopyDBClusterParameterGroup", "2014-10-31");
#[allow(unused_mut)]
let mut scope_50 = writer.prefix("SourceDBClusterParameterGroupIdentifier");
if let Some(var_51) = &input.source_db_cluster_parameter_group_identifier {
scope_50.string(var_51);
}
#[allow(unused_mut)]
let mut scope_52 = writer.prefix("TargetDBClusterParameterGroupIdentifier");
if let Some(var_53) = &input.target_db_cluster_parameter_group_identifier {
scope_52.string(var_53);
}
#[allow(unused_mut)]
let mut scope_54 = writer.prefix("TargetDBClusterParameterGroupDescription");
if let Some(var_55) = &input.target_db_cluster_parameter_group_description {
scope_54.string(var_55);
}
#[allow(unused_mut)]
let mut scope_56 = writer.prefix("Tags");
if let Some(var_57) = &input.tags {
let mut list_59 = scope_56.start_list(false, Some("Tag"));
for item_58 in var_57 {
#[allow(unused_mut)]
let mut entry_60 = list_59.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_60, item_58)?;
}
list_59.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_copy_db_cluster_snapshot(
input: &crate::input::CopyDbClusterSnapshotInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CopyDBClusterSnapshot", "2014-10-31");
#[allow(unused_mut)]
let mut scope_61 = writer.prefix("SourceDBClusterSnapshotIdentifier");
if let Some(var_62) = &input.source_db_cluster_snapshot_identifier {
scope_61.string(var_62);
}
#[allow(unused_mut)]
let mut scope_63 = writer.prefix("TargetDBClusterSnapshotIdentifier");
if let Some(var_64) = &input.target_db_cluster_snapshot_identifier {
scope_63.string(var_64);
}
#[allow(unused_mut)]
let mut scope_65 = writer.prefix("KmsKeyId");
if let Some(var_66) = &input.kms_key_id {
scope_65.string(var_66);
}
#[allow(unused_mut)]
let mut scope_67 = writer.prefix("PreSignedUrl");
if let Some(var_68) = &input.pre_signed_url {
scope_67.string(var_68);
}
#[allow(unused_mut)]
let mut scope_69 = writer.prefix("CopyTags");
if let Some(var_70) = &input.copy_tags {
scope_69.boolean(*var_70);
}
#[allow(unused_mut)]
let mut scope_71 = writer.prefix("Tags");
if let Some(var_72) = &input.tags {
let mut list_74 = scope_71.start_list(false, Some("Tag"));
for item_73 in var_72 {
#[allow(unused_mut)]
let mut entry_75 = list_74.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_75, item_73)?;
}
list_74.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_copy_db_parameter_group(
input: &crate::input::CopyDbParameterGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CopyDBParameterGroup", "2014-10-31");
#[allow(unused_mut)]
let mut scope_76 = writer.prefix("SourceDBParameterGroupIdentifier");
if let Some(var_77) = &input.source_db_parameter_group_identifier {
scope_76.string(var_77);
}
#[allow(unused_mut)]
let mut scope_78 = writer.prefix("TargetDBParameterGroupIdentifier");
if let Some(var_79) = &input.target_db_parameter_group_identifier {
scope_78.string(var_79);
}
#[allow(unused_mut)]
let mut scope_80 = writer.prefix("TargetDBParameterGroupDescription");
if let Some(var_81) = &input.target_db_parameter_group_description {
scope_80.string(var_81);
}
#[allow(unused_mut)]
let mut scope_82 = writer.prefix("Tags");
if let Some(var_83) = &input.tags {
let mut list_85 = scope_82.start_list(false, Some("Tag"));
for item_84 in var_83 {
#[allow(unused_mut)]
let mut entry_86 = list_85.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_86, item_84)?;
}
list_85.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_copy_db_snapshot(
input: &crate::input::CopyDbSnapshotInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CopyDBSnapshot", "2014-10-31");
#[allow(unused_mut)]
let mut scope_87 = writer.prefix("SourceDBSnapshotIdentifier");
if let Some(var_88) = &input.source_db_snapshot_identifier {
scope_87.string(var_88);
}
#[allow(unused_mut)]
let mut scope_89 = writer.prefix("TargetDBSnapshotIdentifier");
if let Some(var_90) = &input.target_db_snapshot_identifier {
scope_89.string(var_90);
}
#[allow(unused_mut)]
let mut scope_91 = writer.prefix("KmsKeyId");
if let Some(var_92) = &input.kms_key_id {
scope_91.string(var_92);
}
#[allow(unused_mut)]
let mut scope_93 = writer.prefix("Tags");
if let Some(var_94) = &input.tags {
let mut list_96 = scope_93.start_list(false, Some("Tag"));
for item_95 in var_94 {
#[allow(unused_mut)]
let mut entry_97 = list_96.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_97, item_95)?;
}
list_96.finish();
}
#[allow(unused_mut)]
let mut scope_98 = writer.prefix("CopyTags");
if let Some(var_99) = &input.copy_tags {
scope_98.boolean(*var_99);
}
#[allow(unused_mut)]
let mut scope_100 = writer.prefix("PreSignedUrl");
if let Some(var_101) = &input.pre_signed_url {
scope_100.string(var_101);
}
#[allow(unused_mut)]
let mut scope_102 = writer.prefix("OptionGroupName");
if let Some(var_103) = &input.option_group_name {
scope_102.string(var_103);
}
#[allow(unused_mut)]
let mut scope_104 = writer.prefix("TargetCustomAvailabilityZone");
if let Some(var_105) = &input.target_custom_availability_zone {
scope_104.string(var_105);
}
#[allow(unused_mut)]
let mut scope_106 = writer.prefix("CopyOptionGroup");
if let Some(var_107) = &input.copy_option_group {
scope_106.boolean(*var_107);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_copy_option_group(
input: &crate::input::CopyOptionGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CopyOptionGroup", "2014-10-31");
#[allow(unused_mut)]
let mut scope_108 = writer.prefix("SourceOptionGroupIdentifier");
if let Some(var_109) = &input.source_option_group_identifier {
scope_108.string(var_109);
}
#[allow(unused_mut)]
let mut scope_110 = writer.prefix("TargetOptionGroupIdentifier");
if let Some(var_111) = &input.target_option_group_identifier {
scope_110.string(var_111);
}
#[allow(unused_mut)]
let mut scope_112 = writer.prefix("TargetOptionGroupDescription");
if let Some(var_113) = &input.target_option_group_description {
scope_112.string(var_113);
}
#[allow(unused_mut)]
let mut scope_114 = writer.prefix("Tags");
if let Some(var_115) = &input.tags {
let mut list_117 = scope_114.start_list(false, Some("Tag"));
for item_116 in var_115 {
#[allow(unused_mut)]
let mut entry_118 = list_117.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_118, item_116)?;
}
list_117.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_blue_green_deployment(
input: &crate::input::CreateBlueGreenDeploymentInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateBlueGreenDeployment", "2014-10-31");
#[allow(unused_mut)]
let mut scope_119 = writer.prefix("BlueGreenDeploymentName");
if let Some(var_120) = &input.blue_green_deployment_name {
scope_119.string(var_120);
}
#[allow(unused_mut)]
let mut scope_121 = writer.prefix("Source");
if let Some(var_122) = &input.source {
scope_121.string(var_122);
}
#[allow(unused_mut)]
let mut scope_123 = writer.prefix("TargetEngineVersion");
if let Some(var_124) = &input.target_engine_version {
scope_123.string(var_124);
}
#[allow(unused_mut)]
let mut scope_125 = writer.prefix("TargetDBParameterGroupName");
if let Some(var_126) = &input.target_db_parameter_group_name {
scope_125.string(var_126);
}
#[allow(unused_mut)]
let mut scope_127 = writer.prefix("TargetDBClusterParameterGroupName");
if let Some(var_128) = &input.target_db_cluster_parameter_group_name {
scope_127.string(var_128);
}
#[allow(unused_mut)]
let mut scope_129 = writer.prefix("Tags");
if let Some(var_130) = &input.tags {
let mut list_132 = scope_129.start_list(false, Some("Tag"));
for item_131 in var_130 {
#[allow(unused_mut)]
let mut entry_133 = list_132.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_133, item_131)?;
}
list_132.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_custom_db_engine_version(
input: &crate::input::CreateCustomDbEngineVersionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateCustomDBEngineVersion", "2014-10-31");
#[allow(unused_mut)]
let mut scope_134 = writer.prefix("Engine");
if let Some(var_135) = &input.engine {
scope_134.string(var_135);
}
#[allow(unused_mut)]
let mut scope_136 = writer.prefix("EngineVersion");
if let Some(var_137) = &input.engine_version {
scope_136.string(var_137);
}
#[allow(unused_mut)]
let mut scope_138 = writer.prefix("DatabaseInstallationFilesS3BucketName");
if let Some(var_139) = &input.database_installation_files_s3_bucket_name {
scope_138.string(var_139);
}
#[allow(unused_mut)]
let mut scope_140 = writer.prefix("DatabaseInstallationFilesS3Prefix");
if let Some(var_141) = &input.database_installation_files_s3_prefix {
scope_140.string(var_141);
}
#[allow(unused_mut)]
let mut scope_142 = writer.prefix("ImageId");
if let Some(var_143) = &input.image_id {
scope_142.string(var_143);
}
#[allow(unused_mut)]
let mut scope_144 = writer.prefix("KMSKeyId");
if let Some(var_145) = &input.kms_key_id {
scope_144.string(var_145);
}
#[allow(unused_mut)]
let mut scope_146 = writer.prefix("Description");
if let Some(var_147) = &input.description {
scope_146.string(var_147);
}
#[allow(unused_mut)]
let mut scope_148 = writer.prefix("Manifest");
if let Some(var_149) = &input.manifest {
scope_148.string(var_149);
}
#[allow(unused_mut)]
let mut scope_150 = writer.prefix("Tags");
if let Some(var_151) = &input.tags {
let mut list_153 = scope_150.start_list(false, Some("Tag"));
for item_152 in var_151 {
#[allow(unused_mut)]
let mut entry_154 = list_153.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_154, item_152)?;
}
list_153.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_db_cluster(
input: &crate::input::CreateDbClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateDBCluster", "2014-10-31");
#[allow(unused_mut)]
let mut scope_155 = writer.prefix("AvailabilityZones");
if let Some(var_156) = &input.availability_zones {
let mut list_158 = scope_155.start_list(false, Some("AvailabilityZone"));
for item_157 in var_156 {
#[allow(unused_mut)]
let mut entry_159 = list_158.entry();
entry_159.string(item_157);
}
list_158.finish();
}
#[allow(unused_mut)]
let mut scope_160 = writer.prefix("BackupRetentionPeriod");
if let Some(var_161) = &input.backup_retention_period {
scope_160.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_161).into()),
);
}
#[allow(unused_mut)]
let mut scope_162 = writer.prefix("CharacterSetName");
if let Some(var_163) = &input.character_set_name {
scope_162.string(var_163);
}
#[allow(unused_mut)]
let mut scope_164 = writer.prefix("DatabaseName");
if let Some(var_165) = &input.database_name {
scope_164.string(var_165);
}
#[allow(unused_mut)]
let mut scope_166 = writer.prefix("DBClusterIdentifier");
if let Some(var_167) = &input.db_cluster_identifier {
scope_166.string(var_167);
}
#[allow(unused_mut)]
let mut scope_168 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_169) = &input.db_cluster_parameter_group_name {
scope_168.string(var_169);
}
#[allow(unused_mut)]
let mut scope_170 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_171) = &input.vpc_security_group_ids {
let mut list_173 = scope_170.start_list(false, Some("VpcSecurityGroupId"));
for item_172 in var_171 {
#[allow(unused_mut)]
let mut entry_174 = list_173.entry();
entry_174.string(item_172);
}
list_173.finish();
}
#[allow(unused_mut)]
let mut scope_175 = writer.prefix("DBSubnetGroupName");
if let Some(var_176) = &input.db_subnet_group_name {
scope_175.string(var_176);
}
#[allow(unused_mut)]
let mut scope_177 = writer.prefix("Engine");
if let Some(var_178) = &input.engine {
scope_177.string(var_178);
}
#[allow(unused_mut)]
let mut scope_179 = writer.prefix("EngineVersion");
if let Some(var_180) = &input.engine_version {
scope_179.string(var_180);
}
#[allow(unused_mut)]
let mut scope_181 = writer.prefix("Port");
if let Some(var_182) = &input.port {
scope_181.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_182).into()),
);
}
#[allow(unused_mut)]
let mut scope_183 = writer.prefix("MasterUsername");
if let Some(var_184) = &input.master_username {
scope_183.string(var_184);
}
#[allow(unused_mut)]
let mut scope_185 = writer.prefix("MasterUserPassword");
if let Some(var_186) = &input.master_user_password {
scope_185.string(var_186);
}
#[allow(unused_mut)]
let mut scope_187 = writer.prefix("OptionGroupName");
if let Some(var_188) = &input.option_group_name {
scope_187.string(var_188);
}
#[allow(unused_mut)]
let mut scope_189 = writer.prefix("PreferredBackupWindow");
if let Some(var_190) = &input.preferred_backup_window {
scope_189.string(var_190);
}
#[allow(unused_mut)]
let mut scope_191 = writer.prefix("PreferredMaintenanceWindow");
if let Some(var_192) = &input.preferred_maintenance_window {
scope_191.string(var_192);
}
#[allow(unused_mut)]
let mut scope_193 = writer.prefix("ReplicationSourceIdentifier");
if let Some(var_194) = &input.replication_source_identifier {
scope_193.string(var_194);
}
#[allow(unused_mut)]
let mut scope_195 = writer.prefix("Tags");
if let Some(var_196) = &input.tags {
let mut list_198 = scope_195.start_list(false, Some("Tag"));
for item_197 in var_196 {
#[allow(unused_mut)]
let mut entry_199 = list_198.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_199, item_197)?;
}
list_198.finish();
}
#[allow(unused_mut)]
let mut scope_200 = writer.prefix("StorageEncrypted");
if let Some(var_201) = &input.storage_encrypted {
scope_200.boolean(*var_201);
}
#[allow(unused_mut)]
let mut scope_202 = writer.prefix("KmsKeyId");
if let Some(var_203) = &input.kms_key_id {
scope_202.string(var_203);
}
#[allow(unused_mut)]
let mut scope_204 = writer.prefix("PreSignedUrl");
if let Some(var_205) = &input.pre_signed_url {
scope_204.string(var_205);
}
#[allow(unused_mut)]
let mut scope_206 = writer.prefix("EnableIAMDatabaseAuthentication");
if let Some(var_207) = &input.enable_iam_database_authentication {
scope_206.boolean(*var_207);
}
#[allow(unused_mut)]
let mut scope_208 = writer.prefix("BacktrackWindow");
if let Some(var_209) = &input.backtrack_window {
scope_208.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_209).into()),
);
}
#[allow(unused_mut)]
let mut scope_210 = writer.prefix("EnableCloudwatchLogsExports");
if let Some(var_211) = &input.enable_cloudwatch_logs_exports {
let mut list_213 = scope_210.start_list(false, None);
for item_212 in var_211 {
#[allow(unused_mut)]
let mut entry_214 = list_213.entry();
entry_214.string(item_212);
}
list_213.finish();
}
#[allow(unused_mut)]
let mut scope_215 = writer.prefix("EngineMode");
if let Some(var_216) = &input.engine_mode {
scope_215.string(var_216);
}
#[allow(unused_mut)]
let mut scope_217 = writer.prefix("ScalingConfiguration");
if let Some(var_218) = &input.scaling_configuration {
crate::query_ser::serialize_structure_crate_model_scaling_configuration(
scope_217, var_218,
)?;
}
#[allow(unused_mut)]
let mut scope_219 = writer.prefix("DeletionProtection");
if let Some(var_220) = &input.deletion_protection {
scope_219.boolean(*var_220);
}
#[allow(unused_mut)]
let mut scope_221 = writer.prefix("GlobalClusterIdentifier");
if let Some(var_222) = &input.global_cluster_identifier {
scope_221.string(var_222);
}
#[allow(unused_mut)]
let mut scope_223 = writer.prefix("EnableHttpEndpoint");
if let Some(var_224) = &input.enable_http_endpoint {
scope_223.boolean(*var_224);
}
#[allow(unused_mut)]
let mut scope_225 = writer.prefix("CopyTagsToSnapshot");
if let Some(var_226) = &input.copy_tags_to_snapshot {
scope_225.boolean(*var_226);
}
#[allow(unused_mut)]
let mut scope_227 = writer.prefix("Domain");
if let Some(var_228) = &input.domain {
scope_227.string(var_228);
}
#[allow(unused_mut)]
let mut scope_229 = writer.prefix("DomainIAMRoleName");
if let Some(var_230) = &input.domain_iam_role_name {
scope_229.string(var_230);
}
#[allow(unused_mut)]
let mut scope_231 = writer.prefix("EnableGlobalWriteForwarding");
if let Some(var_232) = &input.enable_global_write_forwarding {
scope_231.boolean(*var_232);
}
#[allow(unused_mut)]
let mut scope_233 = writer.prefix("DBClusterInstanceClass");
if let Some(var_234) = &input.db_cluster_instance_class {
scope_233.string(var_234);
}
#[allow(unused_mut)]
let mut scope_235 = writer.prefix("AllocatedStorage");
if let Some(var_236) = &input.allocated_storage {
scope_235.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_236).into()),
);
}
#[allow(unused_mut)]
let mut scope_237 = writer.prefix("StorageType");
if let Some(var_238) = &input.storage_type {
scope_237.string(var_238);
}
#[allow(unused_mut)]
let mut scope_239 = writer.prefix("Iops");
if let Some(var_240) = &input.iops {
scope_239.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_240).into()),
);
}
#[allow(unused_mut)]
let mut scope_241 = writer.prefix("PubliclyAccessible");
if let Some(var_242) = &input.publicly_accessible {
scope_241.boolean(*var_242);
}
#[allow(unused_mut)]
let mut scope_243 = writer.prefix("AutoMinorVersionUpgrade");
if let Some(var_244) = &input.auto_minor_version_upgrade {
scope_243.boolean(*var_244);
}
#[allow(unused_mut)]
let mut scope_245 = writer.prefix("MonitoringInterval");
if let Some(var_246) = &input.monitoring_interval {
scope_245.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_246).into()),
);
}
#[allow(unused_mut)]
let mut scope_247 = writer.prefix("MonitoringRoleArn");
if let Some(var_248) = &input.monitoring_role_arn {
scope_247.string(var_248);
}
#[allow(unused_mut)]
let mut scope_249 = writer.prefix("EnablePerformanceInsights");
if let Some(var_250) = &input.enable_performance_insights {
scope_249.boolean(*var_250);
}
#[allow(unused_mut)]
let mut scope_251 = writer.prefix("PerformanceInsightsKMSKeyId");
if let Some(var_252) = &input.performance_insights_kms_key_id {
scope_251.string(var_252);
}
#[allow(unused_mut)]
let mut scope_253 = writer.prefix("PerformanceInsightsRetentionPeriod");
if let Some(var_254) = &input.performance_insights_retention_period {
scope_253.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_254).into()),
);
}
#[allow(unused_mut)]
let mut scope_255 = writer.prefix("ServerlessV2ScalingConfiguration");
if let Some(var_256) = &input.serverless_v2_scaling_configuration {
crate::query_ser::serialize_structure_crate_model_serverless_v2_scaling_configuration(
scope_255, var_256,
)?;
}
#[allow(unused_mut)]
let mut scope_257 = writer.prefix("NetworkType");
if let Some(var_258) = &input.network_type {
scope_257.string(var_258);
}
#[allow(unused_mut)]
let mut scope_259 = writer.prefix("DBSystemId");
if let Some(var_260) = &input.db_system_id {
scope_259.string(var_260);
}
#[allow(unused_mut)]
let mut scope_261 = writer.prefix("ManageMasterUserPassword");
if let Some(var_262) = &input.manage_master_user_password {
scope_261.boolean(*var_262);
}
#[allow(unused_mut)]
let mut scope_263 = writer.prefix("MasterUserSecretKmsKeyId");
if let Some(var_264) = &input.master_user_secret_kms_key_id {
scope_263.string(var_264);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_db_cluster_endpoint(
input: &crate::input::CreateDbClusterEndpointInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateDBClusterEndpoint", "2014-10-31");
#[allow(unused_mut)]
let mut scope_265 = writer.prefix("DBClusterIdentifier");
if let Some(var_266) = &input.db_cluster_identifier {
scope_265.string(var_266);
}
#[allow(unused_mut)]
let mut scope_267 = writer.prefix("DBClusterEndpointIdentifier");
if let Some(var_268) = &input.db_cluster_endpoint_identifier {
scope_267.string(var_268);
}
#[allow(unused_mut)]
let mut scope_269 = writer.prefix("EndpointType");
if let Some(var_270) = &input.endpoint_type {
scope_269.string(var_270);
}
#[allow(unused_mut)]
let mut scope_271 = writer.prefix("StaticMembers");
if let Some(var_272) = &input.static_members {
let mut list_274 = scope_271.start_list(false, None);
for item_273 in var_272 {
#[allow(unused_mut)]
let mut entry_275 = list_274.entry();
entry_275.string(item_273);
}
list_274.finish();
}
#[allow(unused_mut)]
let mut scope_276 = writer.prefix("ExcludedMembers");
if let Some(var_277) = &input.excluded_members {
let mut list_279 = scope_276.start_list(false, None);
for item_278 in var_277 {
#[allow(unused_mut)]
let mut entry_280 = list_279.entry();
entry_280.string(item_278);
}
list_279.finish();
}
#[allow(unused_mut)]
let mut scope_281 = writer.prefix("Tags");
if let Some(var_282) = &input.tags {
let mut list_284 = scope_281.start_list(false, Some("Tag"));
for item_283 in var_282 {
#[allow(unused_mut)]
let mut entry_285 = list_284.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_285, item_283)?;
}
list_284.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_db_cluster_parameter_group(
input: &crate::input::CreateDbClusterParameterGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateDBClusterParameterGroup", "2014-10-31");
#[allow(unused_mut)]
let mut scope_286 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_287) = &input.db_cluster_parameter_group_name {
scope_286.string(var_287);
}
#[allow(unused_mut)]
let mut scope_288 = writer.prefix("DBParameterGroupFamily");
if let Some(var_289) = &input.db_parameter_group_family {
scope_288.string(var_289);
}
#[allow(unused_mut)]
let mut scope_290 = writer.prefix("Description");
if let Some(var_291) = &input.description {
scope_290.string(var_291);
}
#[allow(unused_mut)]
let mut scope_292 = writer.prefix("Tags");
if let Some(var_293) = &input.tags {
let mut list_295 = scope_292.start_list(false, Some("Tag"));
for item_294 in var_293 {
#[allow(unused_mut)]
let mut entry_296 = list_295.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_296, item_294)?;
}
list_295.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_db_cluster_snapshot(
input: &crate::input::CreateDbClusterSnapshotInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateDBClusterSnapshot", "2014-10-31");
#[allow(unused_mut)]
let mut scope_297 = writer.prefix("DBClusterSnapshotIdentifier");
if let Some(var_298) = &input.db_cluster_snapshot_identifier {
scope_297.string(var_298);
}
#[allow(unused_mut)]
let mut scope_299 = writer.prefix("DBClusterIdentifier");
if let Some(var_300) = &input.db_cluster_identifier {
scope_299.string(var_300);
}
#[allow(unused_mut)]
let mut scope_301 = writer.prefix("Tags");
if let Some(var_302) = &input.tags {
let mut list_304 = scope_301.start_list(false, Some("Tag"));
for item_303 in var_302 {
#[allow(unused_mut)]
let mut entry_305 = list_304.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_305, item_303)?;
}
list_304.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_db_instance(
input: &crate::input::CreateDbInstanceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateDBInstance", "2014-10-31");
#[allow(unused_mut)]
let mut scope_306 = writer.prefix("DBName");
if let Some(var_307) = &input.db_name {
scope_306.string(var_307);
}
#[allow(unused_mut)]
let mut scope_308 = writer.prefix("DBInstanceIdentifier");
if let Some(var_309) = &input.db_instance_identifier {
scope_308.string(var_309);
}
#[allow(unused_mut)]
let mut scope_310 = writer.prefix("AllocatedStorage");
if let Some(var_311) = &input.allocated_storage {
scope_310.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_311).into()),
);
}
#[allow(unused_mut)]
let mut scope_312 = writer.prefix("DBInstanceClass");
if let Some(var_313) = &input.db_instance_class {
scope_312.string(var_313);
}
#[allow(unused_mut)]
let mut scope_314 = writer.prefix("Engine");
if let Some(var_315) = &input.engine {
scope_314.string(var_315);
}
#[allow(unused_mut)]
let mut scope_316 = writer.prefix("MasterUsername");
if let Some(var_317) = &input.master_username {
scope_316.string(var_317);
}
#[allow(unused_mut)]
let mut scope_318 = writer.prefix("MasterUserPassword");
if let Some(var_319) = &input.master_user_password {
scope_318.string(var_319);
}
#[allow(unused_mut)]
let mut scope_320 = writer.prefix("DBSecurityGroups");
if let Some(var_321) = &input.db_security_groups {
let mut list_323 = scope_320.start_list(false, Some("DBSecurityGroupName"));
for item_322 in var_321 {
#[allow(unused_mut)]
let mut entry_324 = list_323.entry();
entry_324.string(item_322);
}
list_323.finish();
}
#[allow(unused_mut)]
let mut scope_325 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_326) = &input.vpc_security_group_ids {
let mut list_328 = scope_325.start_list(false, Some("VpcSecurityGroupId"));
for item_327 in var_326 {
#[allow(unused_mut)]
let mut entry_329 = list_328.entry();
entry_329.string(item_327);
}
list_328.finish();
}
#[allow(unused_mut)]
let mut scope_330 = writer.prefix("AvailabilityZone");
if let Some(var_331) = &input.availability_zone {
scope_330.string(var_331);
}
#[allow(unused_mut)]
let mut scope_332 = writer.prefix("DBSubnetGroupName");
if let Some(var_333) = &input.db_subnet_group_name {
scope_332.string(var_333);
}
#[allow(unused_mut)]
let mut scope_334 = writer.prefix("PreferredMaintenanceWindow");
if let Some(var_335) = &input.preferred_maintenance_window {
scope_334.string(var_335);
}
#[allow(unused_mut)]
let mut scope_336 = writer.prefix("DBParameterGroupName");
if let Some(var_337) = &input.db_parameter_group_name {
scope_336.string(var_337);
}
#[allow(unused_mut)]
let mut scope_338 = writer.prefix("BackupRetentionPeriod");
if let Some(var_339) = &input.backup_retention_period {
scope_338.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_339).into()),
);
}
#[allow(unused_mut)]
let mut scope_340 = writer.prefix("PreferredBackupWindow");
if let Some(var_341) = &input.preferred_backup_window {
scope_340.string(var_341);
}
#[allow(unused_mut)]
let mut scope_342 = writer.prefix("Port");
if let Some(var_343) = &input.port {
scope_342.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_343).into()),
);
}
#[allow(unused_mut)]
let mut scope_344 = writer.prefix("MultiAZ");
if let Some(var_345) = &input.multi_az {
scope_344.boolean(*var_345);
}
#[allow(unused_mut)]
let mut scope_346 = writer.prefix("EngineVersion");
if let Some(var_347) = &input.engine_version {
scope_346.string(var_347);
}
#[allow(unused_mut)]
let mut scope_348 = writer.prefix("AutoMinorVersionUpgrade");
if let Some(var_349) = &input.auto_minor_version_upgrade {
scope_348.boolean(*var_349);
}
#[allow(unused_mut)]
let mut scope_350 = writer.prefix("LicenseModel");
if let Some(var_351) = &input.license_model {
scope_350.string(var_351);
}
#[allow(unused_mut)]
let mut scope_352 = writer.prefix("Iops");
if let Some(var_353) = &input.iops {
scope_352.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_353).into()),
);
}
#[allow(unused_mut)]
let mut scope_354 = writer.prefix("OptionGroupName");
if let Some(var_355) = &input.option_group_name {
scope_354.string(var_355);
}
#[allow(unused_mut)]
let mut scope_356 = writer.prefix("CharacterSetName");
if let Some(var_357) = &input.character_set_name {
scope_356.string(var_357);
}
#[allow(unused_mut)]
let mut scope_358 = writer.prefix("NcharCharacterSetName");
if let Some(var_359) = &input.nchar_character_set_name {
scope_358.string(var_359);
}
#[allow(unused_mut)]
let mut scope_360 = writer.prefix("PubliclyAccessible");
if let Some(var_361) = &input.publicly_accessible {
scope_360.boolean(*var_361);
}
#[allow(unused_mut)]
let mut scope_362 = writer.prefix("Tags");
if let Some(var_363) = &input.tags {
let mut list_365 = scope_362.start_list(false, Some("Tag"));
for item_364 in var_363 {
#[allow(unused_mut)]
let mut entry_366 = list_365.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_366, item_364)?;
}
list_365.finish();
}
#[allow(unused_mut)]
let mut scope_367 = writer.prefix("DBClusterIdentifier");
if let Some(var_368) = &input.db_cluster_identifier {
scope_367.string(var_368);
}
#[allow(unused_mut)]
let mut scope_369 = writer.prefix("StorageType");
if let Some(var_370) = &input.storage_type {
scope_369.string(var_370);
}
#[allow(unused_mut)]
let mut scope_371 = writer.prefix("TdeCredentialArn");
if let Some(var_372) = &input.tde_credential_arn {
scope_371.string(var_372);
}
#[allow(unused_mut)]
let mut scope_373 = writer.prefix("TdeCredentialPassword");
if let Some(var_374) = &input.tde_credential_password {
scope_373.string(var_374);
}
#[allow(unused_mut)]
let mut scope_375 = writer.prefix("StorageEncrypted");
if let Some(var_376) = &input.storage_encrypted {
scope_375.boolean(*var_376);
}
#[allow(unused_mut)]
let mut scope_377 = writer.prefix("KmsKeyId");
if let Some(var_378) = &input.kms_key_id {
scope_377.string(var_378);
}
#[allow(unused_mut)]
let mut scope_379 = writer.prefix("Domain");
if let Some(var_380) = &input.domain {
scope_379.string(var_380);
}
#[allow(unused_mut)]
let mut scope_381 = writer.prefix("CopyTagsToSnapshot");
if let Some(var_382) = &input.copy_tags_to_snapshot {
scope_381.boolean(*var_382);
}
#[allow(unused_mut)]
let mut scope_383 = writer.prefix("MonitoringInterval");
if let Some(var_384) = &input.monitoring_interval {
scope_383.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_384).into()),
);
}
#[allow(unused_mut)]
let mut scope_385 = writer.prefix("MonitoringRoleArn");
if let Some(var_386) = &input.monitoring_role_arn {
scope_385.string(var_386);
}
#[allow(unused_mut)]
let mut scope_387 = writer.prefix("DomainIAMRoleName");
if let Some(var_388) = &input.domain_iam_role_name {
scope_387.string(var_388);
}
#[allow(unused_mut)]
let mut scope_389 = writer.prefix("PromotionTier");
if let Some(var_390) = &input.promotion_tier {
scope_389.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_390).into()),
);
}
#[allow(unused_mut)]
let mut scope_391 = writer.prefix("Timezone");
if let Some(var_392) = &input.timezone {
scope_391.string(var_392);
}
#[allow(unused_mut)]
let mut scope_393 = writer.prefix("EnableIAMDatabaseAuthentication");
if let Some(var_394) = &input.enable_iam_database_authentication {
scope_393.boolean(*var_394);
}
#[allow(unused_mut)]
let mut scope_395 = writer.prefix("EnablePerformanceInsights");
if let Some(var_396) = &input.enable_performance_insights {
scope_395.boolean(*var_396);
}
#[allow(unused_mut)]
let mut scope_397 = writer.prefix("PerformanceInsightsKMSKeyId");
if let Some(var_398) = &input.performance_insights_kms_key_id {
scope_397.string(var_398);
}
#[allow(unused_mut)]
let mut scope_399 = writer.prefix("PerformanceInsightsRetentionPeriod");
if let Some(var_400) = &input.performance_insights_retention_period {
scope_399.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_400).into()),
);
}
#[allow(unused_mut)]
let mut scope_401 = writer.prefix("EnableCloudwatchLogsExports");
if let Some(var_402) = &input.enable_cloudwatch_logs_exports {
let mut list_404 = scope_401.start_list(false, None);
for item_403 in var_402 {
#[allow(unused_mut)]
let mut entry_405 = list_404.entry();
entry_405.string(item_403);
}
list_404.finish();
}
#[allow(unused_mut)]
let mut scope_406 = writer.prefix("ProcessorFeatures");
if let Some(var_407) = &input.processor_features {
let mut list_409 = scope_406.start_list(false, Some("ProcessorFeature"));
for item_408 in var_407 {
#[allow(unused_mut)]
let mut entry_410 = list_409.entry();
crate::query_ser::serialize_structure_crate_model_processor_feature(
entry_410, item_408,
)?;
}
list_409.finish();
}
#[allow(unused_mut)]
let mut scope_411 = writer.prefix("DeletionProtection");
if let Some(var_412) = &input.deletion_protection {
scope_411.boolean(*var_412);
}
#[allow(unused_mut)]
let mut scope_413 = writer.prefix("MaxAllocatedStorage");
if let Some(var_414) = &input.max_allocated_storage {
scope_413.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_414).into()),
);
}
#[allow(unused_mut)]
let mut scope_415 = writer.prefix("EnableCustomerOwnedIp");
if let Some(var_416) = &input.enable_customer_owned_ip {
scope_415.boolean(*var_416);
}
#[allow(unused_mut)]
let mut scope_417 = writer.prefix("CustomIamInstanceProfile");
if let Some(var_418) = &input.custom_iam_instance_profile {
scope_417.string(var_418);
}
#[allow(unused_mut)]
let mut scope_419 = writer.prefix("BackupTarget");
if let Some(var_420) = &input.backup_target {
scope_419.string(var_420);
}
#[allow(unused_mut)]
let mut scope_421 = writer.prefix("NetworkType");
if let Some(var_422) = &input.network_type {
scope_421.string(var_422);
}
#[allow(unused_mut)]
let mut scope_423 = writer.prefix("StorageThroughput");
if let Some(var_424) = &input.storage_throughput {
scope_423.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_424).into()),
);
}
#[allow(unused_mut)]
let mut scope_425 = writer.prefix("ManageMasterUserPassword");
if let Some(var_426) = &input.manage_master_user_password {
scope_425.boolean(*var_426);
}
#[allow(unused_mut)]
let mut scope_427 = writer.prefix("MasterUserSecretKmsKeyId");
if let Some(var_428) = &input.master_user_secret_kms_key_id {
scope_427.string(var_428);
}
#[allow(unused_mut)]
let mut scope_429 = writer.prefix("CACertificateIdentifier");
if let Some(var_430) = &input.ca_certificate_identifier {
scope_429.string(var_430);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_db_instance_read_replica(
input: &crate::input::CreateDbInstanceReadReplicaInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateDBInstanceReadReplica", "2014-10-31");
#[allow(unused_mut)]
let mut scope_431 = writer.prefix("DBInstanceIdentifier");
if let Some(var_432) = &input.db_instance_identifier {
scope_431.string(var_432);
}
#[allow(unused_mut)]
let mut scope_433 = writer.prefix("SourceDBInstanceIdentifier");
if let Some(var_434) = &input.source_db_instance_identifier {
scope_433.string(var_434);
}
#[allow(unused_mut)]
let mut scope_435 = writer.prefix("DBInstanceClass");
if let Some(var_436) = &input.db_instance_class {
scope_435.string(var_436);
}
#[allow(unused_mut)]
let mut scope_437 = writer.prefix("AvailabilityZone");
if let Some(var_438) = &input.availability_zone {
scope_437.string(var_438);
}
#[allow(unused_mut)]
let mut scope_439 = writer.prefix("Port");
if let Some(var_440) = &input.port {
scope_439.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_440).into()),
);
}
#[allow(unused_mut)]
let mut scope_441 = writer.prefix("MultiAZ");
if let Some(var_442) = &input.multi_az {
scope_441.boolean(*var_442);
}
#[allow(unused_mut)]
let mut scope_443 = writer.prefix("AutoMinorVersionUpgrade");
if let Some(var_444) = &input.auto_minor_version_upgrade {
scope_443.boolean(*var_444);
}
#[allow(unused_mut)]
let mut scope_445 = writer.prefix("Iops");
if let Some(var_446) = &input.iops {
scope_445.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_446).into()),
);
}
#[allow(unused_mut)]
let mut scope_447 = writer.prefix("OptionGroupName");
if let Some(var_448) = &input.option_group_name {
scope_447.string(var_448);
}
#[allow(unused_mut)]
let mut scope_449 = writer.prefix("DBParameterGroupName");
if let Some(var_450) = &input.db_parameter_group_name {
scope_449.string(var_450);
}
#[allow(unused_mut)]
let mut scope_451 = writer.prefix("PubliclyAccessible");
if let Some(var_452) = &input.publicly_accessible {
scope_451.boolean(*var_452);
}
#[allow(unused_mut)]
let mut scope_453 = writer.prefix("Tags");
if let Some(var_454) = &input.tags {
let mut list_456 = scope_453.start_list(false, Some("Tag"));
for item_455 in var_454 {
#[allow(unused_mut)]
let mut entry_457 = list_456.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_457, item_455)?;
}
list_456.finish();
}
#[allow(unused_mut)]
let mut scope_458 = writer.prefix("DBSubnetGroupName");
if let Some(var_459) = &input.db_subnet_group_name {
scope_458.string(var_459);
}
#[allow(unused_mut)]
let mut scope_460 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_461) = &input.vpc_security_group_ids {
let mut list_463 = scope_460.start_list(false, Some("VpcSecurityGroupId"));
for item_462 in var_461 {
#[allow(unused_mut)]
let mut entry_464 = list_463.entry();
entry_464.string(item_462);
}
list_463.finish();
}
#[allow(unused_mut)]
let mut scope_465 = writer.prefix("StorageType");
if let Some(var_466) = &input.storage_type {
scope_465.string(var_466);
}
#[allow(unused_mut)]
let mut scope_467 = writer.prefix("CopyTagsToSnapshot");
if let Some(var_468) = &input.copy_tags_to_snapshot {
scope_467.boolean(*var_468);
}
#[allow(unused_mut)]
let mut scope_469 = writer.prefix("MonitoringInterval");
if let Some(var_470) = &input.monitoring_interval {
scope_469.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_470).into()),
);
}
#[allow(unused_mut)]
let mut scope_471 = writer.prefix("MonitoringRoleArn");
if let Some(var_472) = &input.monitoring_role_arn {
scope_471.string(var_472);
}
#[allow(unused_mut)]
let mut scope_473 = writer.prefix("KmsKeyId");
if let Some(var_474) = &input.kms_key_id {
scope_473.string(var_474);
}
#[allow(unused_mut)]
let mut scope_475 = writer.prefix("PreSignedUrl");
if let Some(var_476) = &input.pre_signed_url {
scope_475.string(var_476);
}
#[allow(unused_mut)]
let mut scope_477 = writer.prefix("EnableIAMDatabaseAuthentication");
if let Some(var_478) = &input.enable_iam_database_authentication {
scope_477.boolean(*var_478);
}
#[allow(unused_mut)]
let mut scope_479 = writer.prefix("EnablePerformanceInsights");
if let Some(var_480) = &input.enable_performance_insights {
scope_479.boolean(*var_480);
}
#[allow(unused_mut)]
let mut scope_481 = writer.prefix("PerformanceInsightsKMSKeyId");
if let Some(var_482) = &input.performance_insights_kms_key_id {
scope_481.string(var_482);
}
#[allow(unused_mut)]
let mut scope_483 = writer.prefix("PerformanceInsightsRetentionPeriod");
if let Some(var_484) = &input.performance_insights_retention_period {
scope_483.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_484).into()),
);
}
#[allow(unused_mut)]
let mut scope_485 = writer.prefix("EnableCloudwatchLogsExports");
if let Some(var_486) = &input.enable_cloudwatch_logs_exports {
let mut list_488 = scope_485.start_list(false, None);
for item_487 in var_486 {
#[allow(unused_mut)]
let mut entry_489 = list_488.entry();
entry_489.string(item_487);
}
list_488.finish();
}
#[allow(unused_mut)]
let mut scope_490 = writer.prefix("ProcessorFeatures");
if let Some(var_491) = &input.processor_features {
let mut list_493 = scope_490.start_list(false, Some("ProcessorFeature"));
for item_492 in var_491 {
#[allow(unused_mut)]
let mut entry_494 = list_493.entry();
crate::query_ser::serialize_structure_crate_model_processor_feature(
entry_494, item_492,
)?;
}
list_493.finish();
}
#[allow(unused_mut)]
let mut scope_495 = writer.prefix("UseDefaultProcessorFeatures");
if let Some(var_496) = &input.use_default_processor_features {
scope_495.boolean(*var_496);
}
#[allow(unused_mut)]
let mut scope_497 = writer.prefix("DeletionProtection");
if let Some(var_498) = &input.deletion_protection {
scope_497.boolean(*var_498);
}
#[allow(unused_mut)]
let mut scope_499 = writer.prefix("Domain");
if let Some(var_500) = &input.domain {
scope_499.string(var_500);
}
#[allow(unused_mut)]
let mut scope_501 = writer.prefix("DomainIAMRoleName");
if let Some(var_502) = &input.domain_iam_role_name {
scope_501.string(var_502);
}
#[allow(unused_mut)]
let mut scope_503 = writer.prefix("ReplicaMode");
if let Some(var_504) = &input.replica_mode {
scope_503.string(var_504.as_str());
}
#[allow(unused_mut)]
let mut scope_505 = writer.prefix("MaxAllocatedStorage");
if let Some(var_506) = &input.max_allocated_storage {
scope_505.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_506).into()),
);
}
#[allow(unused_mut)]
let mut scope_507 = writer.prefix("CustomIamInstanceProfile");
if let Some(var_508) = &input.custom_iam_instance_profile {
scope_507.string(var_508);
}
#[allow(unused_mut)]
let mut scope_509 = writer.prefix("NetworkType");
if let Some(var_510) = &input.network_type {
scope_509.string(var_510);
}
#[allow(unused_mut)]
let mut scope_511 = writer.prefix("StorageThroughput");
if let Some(var_512) = &input.storage_throughput {
scope_511.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_512).into()),
);
}
#[allow(unused_mut)]
let mut scope_513 = writer.prefix("EnableCustomerOwnedIp");
if let Some(var_514) = &input.enable_customer_owned_ip {
scope_513.boolean(*var_514);
}
#[allow(unused_mut)]
let mut scope_515 = writer.prefix("AllocatedStorage");
if let Some(var_516) = &input.allocated_storage {
scope_515.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_516).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_db_parameter_group(
input: &crate::input::CreateDbParameterGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateDBParameterGroup", "2014-10-31");
#[allow(unused_mut)]
let mut scope_517 = writer.prefix("DBParameterGroupName");
if let Some(var_518) = &input.db_parameter_group_name {
scope_517.string(var_518);
}
#[allow(unused_mut)]
let mut scope_519 = writer.prefix("DBParameterGroupFamily");
if let Some(var_520) = &input.db_parameter_group_family {
scope_519.string(var_520);
}
#[allow(unused_mut)]
let mut scope_521 = writer.prefix("Description");
if let Some(var_522) = &input.description {
scope_521.string(var_522);
}
#[allow(unused_mut)]
let mut scope_523 = writer.prefix("Tags");
if let Some(var_524) = &input.tags {
let mut list_526 = scope_523.start_list(false, Some("Tag"));
for item_525 in var_524 {
#[allow(unused_mut)]
let mut entry_527 = list_526.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_527, item_525)?;
}
list_526.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_db_proxy(
input: &crate::input::CreateDbProxyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateDBProxy", "2014-10-31");
#[allow(unused_mut)]
let mut scope_528 = writer.prefix("DBProxyName");
if let Some(var_529) = &input.db_proxy_name {
scope_528.string(var_529);
}
#[allow(unused_mut)]
let mut scope_530 = writer.prefix("EngineFamily");
if let Some(var_531) = &input.engine_family {
scope_530.string(var_531.as_str());
}
#[allow(unused_mut)]
let mut scope_532 = writer.prefix("Auth");
if let Some(var_533) = &input.auth {
let mut list_535 = scope_532.start_list(false, None);
for item_534 in var_533 {
#[allow(unused_mut)]
let mut entry_536 = list_535.entry();
crate::query_ser::serialize_structure_crate_model_user_auth_config(
entry_536, item_534,
)?;
}
list_535.finish();
}
#[allow(unused_mut)]
let mut scope_537 = writer.prefix("RoleArn");
if let Some(var_538) = &input.role_arn {
scope_537.string(var_538);
}
#[allow(unused_mut)]
let mut scope_539 = writer.prefix("VpcSubnetIds");
if let Some(var_540) = &input.vpc_subnet_ids {
let mut list_542 = scope_539.start_list(false, None);
for item_541 in var_540 {
#[allow(unused_mut)]
let mut entry_543 = list_542.entry();
entry_543.string(item_541);
}
list_542.finish();
}
#[allow(unused_mut)]
let mut scope_544 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_545) = &input.vpc_security_group_ids {
let mut list_547 = scope_544.start_list(false, None);
for item_546 in var_545 {
#[allow(unused_mut)]
let mut entry_548 = list_547.entry();
entry_548.string(item_546);
}
list_547.finish();
}
#[allow(unused_mut)]
let mut scope_549 = writer.prefix("RequireTLS");
if input.require_tls {
scope_549.boolean(input.require_tls);
}
#[allow(unused_mut)]
let mut scope_550 = writer.prefix("IdleClientTimeout");
if let Some(var_551) = &input.idle_client_timeout {
scope_550.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_551).into()),
);
}
#[allow(unused_mut)]
let mut scope_552 = writer.prefix("DebugLogging");
if input.debug_logging {
scope_552.boolean(input.debug_logging);
}
#[allow(unused_mut)]
let mut scope_553 = writer.prefix("Tags");
if let Some(var_554) = &input.tags {
let mut list_556 = scope_553.start_list(false, Some("Tag"));
for item_555 in var_554 {
#[allow(unused_mut)]
let mut entry_557 = list_556.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_557, item_555)?;
}
list_556.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_db_proxy_endpoint(
input: &crate::input::CreateDbProxyEndpointInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateDBProxyEndpoint", "2014-10-31");
#[allow(unused_mut)]
let mut scope_558 = writer.prefix("DBProxyName");
if let Some(var_559) = &input.db_proxy_name {
scope_558.string(var_559);
}
#[allow(unused_mut)]
let mut scope_560 = writer.prefix("DBProxyEndpointName");
if let Some(var_561) = &input.db_proxy_endpoint_name {
scope_560.string(var_561);
}
#[allow(unused_mut)]
let mut scope_562 = writer.prefix("VpcSubnetIds");
if let Some(var_563) = &input.vpc_subnet_ids {
let mut list_565 = scope_562.start_list(false, None);
for item_564 in var_563 {
#[allow(unused_mut)]
let mut entry_566 = list_565.entry();
entry_566.string(item_564);
}
list_565.finish();
}
#[allow(unused_mut)]
let mut scope_567 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_568) = &input.vpc_security_group_ids {
let mut list_570 = scope_567.start_list(false, None);
for item_569 in var_568 {
#[allow(unused_mut)]
let mut entry_571 = list_570.entry();
entry_571.string(item_569);
}
list_570.finish();
}
#[allow(unused_mut)]
let mut scope_572 = writer.prefix("TargetRole");
if let Some(var_573) = &input.target_role {
scope_572.string(var_573.as_str());
}
#[allow(unused_mut)]
let mut scope_574 = writer.prefix("Tags");
if let Some(var_575) = &input.tags {
let mut list_577 = scope_574.start_list(false, Some("Tag"));
for item_576 in var_575 {
#[allow(unused_mut)]
let mut entry_578 = list_577.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_578, item_576)?;
}
list_577.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_db_security_group(
input: &crate::input::CreateDbSecurityGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateDBSecurityGroup", "2014-10-31");
#[allow(unused_mut)]
let mut scope_579 = writer.prefix("DBSecurityGroupName");
if let Some(var_580) = &input.db_security_group_name {
scope_579.string(var_580);
}
#[allow(unused_mut)]
let mut scope_581 = writer.prefix("DBSecurityGroupDescription");
if let Some(var_582) = &input.db_security_group_description {
scope_581.string(var_582);
}
#[allow(unused_mut)]
let mut scope_583 = writer.prefix("Tags");
if let Some(var_584) = &input.tags {
let mut list_586 = scope_583.start_list(false, Some("Tag"));
for item_585 in var_584 {
#[allow(unused_mut)]
let mut entry_587 = list_586.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_587, item_585)?;
}
list_586.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_db_snapshot(
input: &crate::input::CreateDbSnapshotInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateDBSnapshot", "2014-10-31");
#[allow(unused_mut)]
let mut scope_588 = writer.prefix("DBSnapshotIdentifier");
if let Some(var_589) = &input.db_snapshot_identifier {
scope_588.string(var_589);
}
#[allow(unused_mut)]
let mut scope_590 = writer.prefix("DBInstanceIdentifier");
if let Some(var_591) = &input.db_instance_identifier {
scope_590.string(var_591);
}
#[allow(unused_mut)]
let mut scope_592 = writer.prefix("Tags");
if let Some(var_593) = &input.tags {
let mut list_595 = scope_592.start_list(false, Some("Tag"));
for item_594 in var_593 {
#[allow(unused_mut)]
let mut entry_596 = list_595.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_596, item_594)?;
}
list_595.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_db_subnet_group(
input: &crate::input::CreateDbSubnetGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateDBSubnetGroup", "2014-10-31");
#[allow(unused_mut)]
let mut scope_597 = writer.prefix("DBSubnetGroupName");
if let Some(var_598) = &input.db_subnet_group_name {
scope_597.string(var_598);
}
#[allow(unused_mut)]
let mut scope_599 = writer.prefix("DBSubnetGroupDescription");
if let Some(var_600) = &input.db_subnet_group_description {
scope_599.string(var_600);
}
#[allow(unused_mut)]
let mut scope_601 = writer.prefix("SubnetIds");
if let Some(var_602) = &input.subnet_ids {
let mut list_604 = scope_601.start_list(false, Some("SubnetIdentifier"));
for item_603 in var_602 {
#[allow(unused_mut)]
let mut entry_605 = list_604.entry();
entry_605.string(item_603);
}
list_604.finish();
}
#[allow(unused_mut)]
let mut scope_606 = writer.prefix("Tags");
if let Some(var_607) = &input.tags {
let mut list_609 = scope_606.start_list(false, Some("Tag"));
for item_608 in var_607 {
#[allow(unused_mut)]
let mut entry_610 = list_609.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_610, item_608)?;
}
list_609.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_event_subscription(
input: &crate::input::CreateEventSubscriptionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateEventSubscription", "2014-10-31");
#[allow(unused_mut)]
let mut scope_611 = writer.prefix("SubscriptionName");
if let Some(var_612) = &input.subscription_name {
scope_611.string(var_612);
}
#[allow(unused_mut)]
let mut scope_613 = writer.prefix("SnsTopicArn");
if let Some(var_614) = &input.sns_topic_arn {
scope_613.string(var_614);
}
#[allow(unused_mut)]
let mut scope_615 = writer.prefix("SourceType");
if let Some(var_616) = &input.source_type {
scope_615.string(var_616);
}
#[allow(unused_mut)]
let mut scope_617 = writer.prefix("EventCategories");
if let Some(var_618) = &input.event_categories {
let mut list_620 = scope_617.start_list(false, Some("EventCategory"));
for item_619 in var_618 {
#[allow(unused_mut)]
let mut entry_621 = list_620.entry();
entry_621.string(item_619);
}
list_620.finish();
}
#[allow(unused_mut)]
let mut scope_622 = writer.prefix("SourceIds");
if let Some(var_623) = &input.source_ids {
let mut list_625 = scope_622.start_list(false, Some("SourceId"));
for item_624 in var_623 {
#[allow(unused_mut)]
let mut entry_626 = list_625.entry();
entry_626.string(item_624);
}
list_625.finish();
}
#[allow(unused_mut)]
let mut scope_627 = writer.prefix("Enabled");
if let Some(var_628) = &input.enabled {
scope_627.boolean(*var_628);
}
#[allow(unused_mut)]
let mut scope_629 = writer.prefix("Tags");
if let Some(var_630) = &input.tags {
let mut list_632 = scope_629.start_list(false, Some("Tag"));
for item_631 in var_630 {
#[allow(unused_mut)]
let mut entry_633 = list_632.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_633, item_631)?;
}
list_632.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_global_cluster(
input: &crate::input::CreateGlobalClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateGlobalCluster", "2014-10-31");
#[allow(unused_mut)]
let mut scope_634 = writer.prefix("GlobalClusterIdentifier");
if let Some(var_635) = &input.global_cluster_identifier {
scope_634.string(var_635);
}
#[allow(unused_mut)]
let mut scope_636 = writer.prefix("SourceDBClusterIdentifier");
if let Some(var_637) = &input.source_db_cluster_identifier {
scope_636.string(var_637);
}
#[allow(unused_mut)]
let mut scope_638 = writer.prefix("Engine");
if let Some(var_639) = &input.engine {
scope_638.string(var_639);
}
#[allow(unused_mut)]
let mut scope_640 = writer.prefix("EngineVersion");
if let Some(var_641) = &input.engine_version {
scope_640.string(var_641);
}
#[allow(unused_mut)]
let mut scope_642 = writer.prefix("DeletionProtection");
if let Some(var_643) = &input.deletion_protection {
scope_642.boolean(*var_643);
}
#[allow(unused_mut)]
let mut scope_644 = writer.prefix("DatabaseName");
if let Some(var_645) = &input.database_name {
scope_644.string(var_645);
}
#[allow(unused_mut)]
let mut scope_646 = writer.prefix("StorageEncrypted");
if let Some(var_647) = &input.storage_encrypted {
scope_646.boolean(*var_647);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_option_group(
input: &crate::input::CreateOptionGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateOptionGroup", "2014-10-31");
#[allow(unused_mut)]
let mut scope_648 = writer.prefix("OptionGroupName");
if let Some(var_649) = &input.option_group_name {
scope_648.string(var_649);
}
#[allow(unused_mut)]
let mut scope_650 = writer.prefix("EngineName");
if let Some(var_651) = &input.engine_name {
scope_650.string(var_651);
}
#[allow(unused_mut)]
let mut scope_652 = writer.prefix("MajorEngineVersion");
if let Some(var_653) = &input.major_engine_version {
scope_652.string(var_653);
}
#[allow(unused_mut)]
let mut scope_654 = writer.prefix("OptionGroupDescription");
if let Some(var_655) = &input.option_group_description {
scope_654.string(var_655);
}
#[allow(unused_mut)]
let mut scope_656 = writer.prefix("Tags");
if let Some(var_657) = &input.tags {
let mut list_659 = scope_656.start_list(false, Some("Tag"));
for item_658 in var_657 {
#[allow(unused_mut)]
let mut entry_660 = list_659.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_660, item_658)?;
}
list_659.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_blue_green_deployment(
input: &crate::input::DeleteBlueGreenDeploymentInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteBlueGreenDeployment", "2014-10-31");
#[allow(unused_mut)]
let mut scope_661 = writer.prefix("BlueGreenDeploymentIdentifier");
if let Some(var_662) = &input.blue_green_deployment_identifier {
scope_661.string(var_662);
}
#[allow(unused_mut)]
let mut scope_663 = writer.prefix("DeleteTarget");
if let Some(var_664) = &input.delete_target {
scope_663.boolean(*var_664);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_custom_db_engine_version(
input: &crate::input::DeleteCustomDbEngineVersionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteCustomDBEngineVersion", "2014-10-31");
#[allow(unused_mut)]
let mut scope_665 = writer.prefix("Engine");
if let Some(var_666) = &input.engine {
scope_665.string(var_666);
}
#[allow(unused_mut)]
let mut scope_667 = writer.prefix("EngineVersion");
if let Some(var_668) = &input.engine_version {
scope_667.string(var_668);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_db_cluster(
input: &crate::input::DeleteDbClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteDBCluster", "2014-10-31");
#[allow(unused_mut)]
let mut scope_669 = writer.prefix("DBClusterIdentifier");
if let Some(var_670) = &input.db_cluster_identifier {
scope_669.string(var_670);
}
#[allow(unused_mut)]
let mut scope_671 = writer.prefix("SkipFinalSnapshot");
if input.skip_final_snapshot {
scope_671.boolean(input.skip_final_snapshot);
}
#[allow(unused_mut)]
let mut scope_672 = writer.prefix("FinalDBSnapshotIdentifier");
if let Some(var_673) = &input.final_db_snapshot_identifier {
scope_672.string(var_673);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_db_cluster_endpoint(
input: &crate::input::DeleteDbClusterEndpointInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteDBClusterEndpoint", "2014-10-31");
#[allow(unused_mut)]
let mut scope_674 = writer.prefix("DBClusterEndpointIdentifier");
if let Some(var_675) = &input.db_cluster_endpoint_identifier {
scope_674.string(var_675);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_db_cluster_parameter_group(
input: &crate::input::DeleteDbClusterParameterGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteDBClusterParameterGroup", "2014-10-31");
#[allow(unused_mut)]
let mut scope_676 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_677) = &input.db_cluster_parameter_group_name {
scope_676.string(var_677);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_db_cluster_snapshot(
input: &crate::input::DeleteDbClusterSnapshotInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteDBClusterSnapshot", "2014-10-31");
#[allow(unused_mut)]
let mut scope_678 = writer.prefix("DBClusterSnapshotIdentifier");
if let Some(var_679) = &input.db_cluster_snapshot_identifier {
scope_678.string(var_679);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_db_instance(
input: &crate::input::DeleteDbInstanceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteDBInstance", "2014-10-31");
#[allow(unused_mut)]
let mut scope_680 = writer.prefix("DBInstanceIdentifier");
if let Some(var_681) = &input.db_instance_identifier {
scope_680.string(var_681);
}
#[allow(unused_mut)]
let mut scope_682 = writer.prefix("SkipFinalSnapshot");
if input.skip_final_snapshot {
scope_682.boolean(input.skip_final_snapshot);
}
#[allow(unused_mut)]
let mut scope_683 = writer.prefix("FinalDBSnapshotIdentifier");
if let Some(var_684) = &input.final_db_snapshot_identifier {
scope_683.string(var_684);
}
#[allow(unused_mut)]
let mut scope_685 = writer.prefix("DeleteAutomatedBackups");
if let Some(var_686) = &input.delete_automated_backups {
scope_685.boolean(*var_686);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_db_instance_automated_backup(
input: &crate::input::DeleteDbInstanceAutomatedBackupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DeleteDBInstanceAutomatedBackup",
"2014-10-31",
);
#[allow(unused_mut)]
let mut scope_687 = writer.prefix("DbiResourceId");
if let Some(var_688) = &input.dbi_resource_id {
scope_687.string(var_688);
}
#[allow(unused_mut)]
let mut scope_689 = writer.prefix("DBInstanceAutomatedBackupsArn");
if let Some(var_690) = &input.db_instance_automated_backups_arn {
scope_689.string(var_690);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_db_parameter_group(
input: &crate::input::DeleteDbParameterGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteDBParameterGroup", "2014-10-31");
#[allow(unused_mut)]
let mut scope_691 = writer.prefix("DBParameterGroupName");
if let Some(var_692) = &input.db_parameter_group_name {
scope_691.string(var_692);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_db_proxy(
input: &crate::input::DeleteDbProxyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteDBProxy", "2014-10-31");
#[allow(unused_mut)]
let mut scope_693 = writer.prefix("DBProxyName");
if let Some(var_694) = &input.db_proxy_name {
scope_693.string(var_694);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_db_proxy_endpoint(
input: &crate::input::DeleteDbProxyEndpointInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteDBProxyEndpoint", "2014-10-31");
#[allow(unused_mut)]
let mut scope_695 = writer.prefix("DBProxyEndpointName");
if let Some(var_696) = &input.db_proxy_endpoint_name {
scope_695.string(var_696);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_db_security_group(
input: &crate::input::DeleteDbSecurityGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteDBSecurityGroup", "2014-10-31");
#[allow(unused_mut)]
let mut scope_697 = writer.prefix("DBSecurityGroupName");
if let Some(var_698) = &input.db_security_group_name {
scope_697.string(var_698);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_db_snapshot(
input: &crate::input::DeleteDbSnapshotInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteDBSnapshot", "2014-10-31");
#[allow(unused_mut)]
let mut scope_699 = writer.prefix("DBSnapshotIdentifier");
if let Some(var_700) = &input.db_snapshot_identifier {
scope_699.string(var_700);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_db_subnet_group(
input: &crate::input::DeleteDbSubnetGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteDBSubnetGroup", "2014-10-31");
#[allow(unused_mut)]
let mut scope_701 = writer.prefix("DBSubnetGroupName");
if let Some(var_702) = &input.db_subnet_group_name {
scope_701.string(var_702);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_event_subscription(
input: &crate::input::DeleteEventSubscriptionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteEventSubscription", "2014-10-31");
#[allow(unused_mut)]
let mut scope_703 = writer.prefix("SubscriptionName");
if let Some(var_704) = &input.subscription_name {
scope_703.string(var_704);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_global_cluster(
input: &crate::input::DeleteGlobalClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteGlobalCluster", "2014-10-31");
#[allow(unused_mut)]
let mut scope_705 = writer.prefix("GlobalClusterIdentifier");
if let Some(var_706) = &input.global_cluster_identifier {
scope_705.string(var_706);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_option_group(
input: &crate::input::DeleteOptionGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteOptionGroup", "2014-10-31");
#[allow(unused_mut)]
let mut scope_707 = writer.prefix("OptionGroupName");
if let Some(var_708) = &input.option_group_name {
scope_707.string(var_708);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_deregister_db_proxy_targets(
input: &crate::input::DeregisterDbProxyTargetsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeregisterDBProxyTargets", "2014-10-31");
#[allow(unused_mut)]
let mut scope_709 = writer.prefix("DBProxyName");
if let Some(var_710) = &input.db_proxy_name {
scope_709.string(var_710);
}
#[allow(unused_mut)]
let mut scope_711 = writer.prefix("TargetGroupName");
if let Some(var_712) = &input.target_group_name {
scope_711.string(var_712);
}
#[allow(unused_mut)]
let mut scope_713 = writer.prefix("DBInstanceIdentifiers");
if let Some(var_714) = &input.db_instance_identifiers {
let mut list_716 = scope_713.start_list(false, None);
for item_715 in var_714 {
#[allow(unused_mut)]
let mut entry_717 = list_716.entry();
entry_717.string(item_715);
}
list_716.finish();
}
#[allow(unused_mut)]
let mut scope_718 = writer.prefix("DBClusterIdentifiers");
if let Some(var_719) = &input.db_cluster_identifiers {
let mut list_721 = scope_718.start_list(false, None);
for item_720 in var_719 {
#[allow(unused_mut)]
let mut entry_722 = list_721.entry();
entry_722.string(item_720);
}
list_721.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_account_attributes(
input: &crate::input::DescribeAccountAttributesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let _ = input;
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeAccountAttributes", "2014-10-31");
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_blue_green_deployments(
input: &crate::input::DescribeBlueGreenDeploymentsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeBlueGreenDeployments", "2014-10-31");
#[allow(unused_mut)]
let mut scope_723 = writer.prefix("BlueGreenDeploymentIdentifier");
if let Some(var_724) = &input.blue_green_deployment_identifier {
scope_723.string(var_724);
}
#[allow(unused_mut)]
let mut scope_725 = writer.prefix("Filters");
if let Some(var_726) = &input.filters {
let mut list_728 = scope_725.start_list(false, Some("Filter"));
for item_727 in var_726 {
#[allow(unused_mut)]
let mut entry_729 = list_728.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_729, item_727)?;
}
list_728.finish();
}
#[allow(unused_mut)]
let mut scope_730 = writer.prefix("Marker");
if let Some(var_731) = &input.marker {
scope_730.string(var_731);
}
#[allow(unused_mut)]
let mut scope_732 = writer.prefix("MaxRecords");
if let Some(var_733) = &input.max_records {
scope_732.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_733).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_certificates(
input: &crate::input::DescribeCertificatesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeCertificates", "2014-10-31");
#[allow(unused_mut)]
let mut scope_734 = writer.prefix("CertificateIdentifier");
if let Some(var_735) = &input.certificate_identifier {
scope_734.string(var_735);
}
#[allow(unused_mut)]
let mut scope_736 = writer.prefix("Filters");
if let Some(var_737) = &input.filters {
let mut list_739 = scope_736.start_list(false, Some("Filter"));
for item_738 in var_737 {
#[allow(unused_mut)]
let mut entry_740 = list_739.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_740, item_738)?;
}
list_739.finish();
}
#[allow(unused_mut)]
let mut scope_741 = writer.prefix("MaxRecords");
if let Some(var_742) = &input.max_records {
scope_741.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_742).into()),
);
}
#[allow(unused_mut)]
let mut scope_743 = writer.prefix("Marker");
if let Some(var_744) = &input.marker {
scope_743.string(var_744);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_db_cluster_backtracks(
input: &crate::input::DescribeDbClusterBacktracksInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeDBClusterBacktracks", "2014-10-31");
#[allow(unused_mut)]
let mut scope_745 = writer.prefix("DBClusterIdentifier");
if let Some(var_746) = &input.db_cluster_identifier {
scope_745.string(var_746);
}
#[allow(unused_mut)]
let mut scope_747 = writer.prefix("BacktrackIdentifier");
if let Some(var_748) = &input.backtrack_identifier {
scope_747.string(var_748);
}
#[allow(unused_mut)]
let mut scope_749 = writer.prefix("Filters");
if let Some(var_750) = &input.filters {
let mut list_752 = scope_749.start_list(false, Some("Filter"));
for item_751 in var_750 {
#[allow(unused_mut)]
let mut entry_753 = list_752.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_753, item_751)?;
}
list_752.finish();
}
#[allow(unused_mut)]
let mut scope_754 = writer.prefix("MaxRecords");
if let Some(var_755) = &input.max_records {
scope_754.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_755).into()),
);
}
#[allow(unused_mut)]
let mut scope_756 = writer.prefix("Marker");
if let Some(var_757) = &input.marker {
scope_756.string(var_757);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_db_cluster_endpoints(
input: &crate::input::DescribeDbClusterEndpointsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeDBClusterEndpoints", "2014-10-31");
#[allow(unused_mut)]
let mut scope_758 = writer.prefix("DBClusterIdentifier");
if let Some(var_759) = &input.db_cluster_identifier {
scope_758.string(var_759);
}
#[allow(unused_mut)]
let mut scope_760 = writer.prefix("DBClusterEndpointIdentifier");
if let Some(var_761) = &input.db_cluster_endpoint_identifier {
scope_760.string(var_761);
}
#[allow(unused_mut)]
let mut scope_762 = writer.prefix("Filters");
if let Some(var_763) = &input.filters {
let mut list_765 = scope_762.start_list(false, Some("Filter"));
for item_764 in var_763 {
#[allow(unused_mut)]
let mut entry_766 = list_765.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_766, item_764)?;
}
list_765.finish();
}
#[allow(unused_mut)]
let mut scope_767 = writer.prefix("MaxRecords");
if let Some(var_768) = &input.max_records {
scope_767.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_768).into()),
);
}
#[allow(unused_mut)]
let mut scope_769 = writer.prefix("Marker");
if let Some(var_770) = &input.marker {
scope_769.string(var_770);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_db_cluster_parameter_groups(
input: &crate::input::DescribeDbClusterParameterGroupsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeDBClusterParameterGroups",
"2014-10-31",
);
#[allow(unused_mut)]
let mut scope_771 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_772) = &input.db_cluster_parameter_group_name {
scope_771.string(var_772);
}
#[allow(unused_mut)]
let mut scope_773 = writer.prefix("Filters");
if let Some(var_774) = &input.filters {
let mut list_776 = scope_773.start_list(false, Some("Filter"));
for item_775 in var_774 {
#[allow(unused_mut)]
let mut entry_777 = list_776.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_777, item_775)?;
}
list_776.finish();
}
#[allow(unused_mut)]
let mut scope_778 = writer.prefix("MaxRecords");
if let Some(var_779) = &input.max_records {
scope_778.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_779).into()),
);
}
#[allow(unused_mut)]
let mut scope_780 = writer.prefix("Marker");
if let Some(var_781) = &input.marker {
scope_780.string(var_781);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_db_cluster_parameters(
input: &crate::input::DescribeDbClusterParametersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeDBClusterParameters", "2014-10-31");
#[allow(unused_mut)]
let mut scope_782 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_783) = &input.db_cluster_parameter_group_name {
scope_782.string(var_783);
}
#[allow(unused_mut)]
let mut scope_784 = writer.prefix("Source");
if let Some(var_785) = &input.source {
scope_784.string(var_785);
}
#[allow(unused_mut)]
let mut scope_786 = writer.prefix("Filters");
if let Some(var_787) = &input.filters {
let mut list_789 = scope_786.start_list(false, Some("Filter"));
for item_788 in var_787 {
#[allow(unused_mut)]
let mut entry_790 = list_789.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_790, item_788)?;
}
list_789.finish();
}
#[allow(unused_mut)]
let mut scope_791 = writer.prefix("MaxRecords");
if let Some(var_792) = &input.max_records {
scope_791.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_792).into()),
);
}
#[allow(unused_mut)]
let mut scope_793 = writer.prefix("Marker");
if let Some(var_794) = &input.marker {
scope_793.string(var_794);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_db_clusters(
input: &crate::input::DescribeDbClustersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeDBClusters", "2014-10-31");
#[allow(unused_mut)]
let mut scope_795 = writer.prefix("DBClusterIdentifier");
if let Some(var_796) = &input.db_cluster_identifier {
scope_795.string(var_796);
}
#[allow(unused_mut)]
let mut scope_797 = writer.prefix("Filters");
if let Some(var_798) = &input.filters {
let mut list_800 = scope_797.start_list(false, Some("Filter"));
for item_799 in var_798 {
#[allow(unused_mut)]
let mut entry_801 = list_800.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_801, item_799)?;
}
list_800.finish();
}
#[allow(unused_mut)]
let mut scope_802 = writer.prefix("MaxRecords");
if let Some(var_803) = &input.max_records {
scope_802.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_803).into()),
);
}
#[allow(unused_mut)]
let mut scope_804 = writer.prefix("Marker");
if let Some(var_805) = &input.marker {
scope_804.string(var_805);
}
#[allow(unused_mut)]
let mut scope_806 = writer.prefix("IncludeShared");
if input.include_shared {
scope_806.boolean(input.include_shared);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_db_cluster_snapshot_attributes(
input: &crate::input::DescribeDbClusterSnapshotAttributesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeDBClusterSnapshotAttributes",
"2014-10-31",
);
#[allow(unused_mut)]
let mut scope_807 = writer.prefix("DBClusterSnapshotIdentifier");
if let Some(var_808) = &input.db_cluster_snapshot_identifier {
scope_807.string(var_808);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_db_cluster_snapshots(
input: &crate::input::DescribeDbClusterSnapshotsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeDBClusterSnapshots", "2014-10-31");
#[allow(unused_mut)]
let mut scope_809 = writer.prefix("DBClusterIdentifier");
if let Some(var_810) = &input.db_cluster_identifier {
scope_809.string(var_810);
}
#[allow(unused_mut)]
let mut scope_811 = writer.prefix("DBClusterSnapshotIdentifier");
if let Some(var_812) = &input.db_cluster_snapshot_identifier {
scope_811.string(var_812);
}
#[allow(unused_mut)]
let mut scope_813 = writer.prefix("SnapshotType");
if let Some(var_814) = &input.snapshot_type {
scope_813.string(var_814);
}
#[allow(unused_mut)]
let mut scope_815 = writer.prefix("Filters");
if let Some(var_816) = &input.filters {
let mut list_818 = scope_815.start_list(false, Some("Filter"));
for item_817 in var_816 {
#[allow(unused_mut)]
let mut entry_819 = list_818.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_819, item_817)?;
}
list_818.finish();
}
#[allow(unused_mut)]
let mut scope_820 = writer.prefix("MaxRecords");
if let Some(var_821) = &input.max_records {
scope_820.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_821).into()),
);
}
#[allow(unused_mut)]
let mut scope_822 = writer.prefix("Marker");
if let Some(var_823) = &input.marker {
scope_822.string(var_823);
}
#[allow(unused_mut)]
let mut scope_824 = writer.prefix("IncludeShared");
if input.include_shared {
scope_824.boolean(input.include_shared);
}
#[allow(unused_mut)]
let mut scope_825 = writer.prefix("IncludePublic");
if input.include_public {
scope_825.boolean(input.include_public);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_db_engine_versions(
input: &crate::input::DescribeDbEngineVersionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeDBEngineVersions", "2014-10-31");
#[allow(unused_mut)]
let mut scope_826 = writer.prefix("Engine");
if let Some(var_827) = &input.engine {
scope_826.string(var_827);
}
#[allow(unused_mut)]
let mut scope_828 = writer.prefix("EngineVersion");
if let Some(var_829) = &input.engine_version {
scope_828.string(var_829);
}
#[allow(unused_mut)]
let mut scope_830 = writer.prefix("DBParameterGroupFamily");
if let Some(var_831) = &input.db_parameter_group_family {
scope_830.string(var_831);
}
#[allow(unused_mut)]
let mut scope_832 = writer.prefix("Filters");
if let Some(var_833) = &input.filters {
let mut list_835 = scope_832.start_list(false, Some("Filter"));
for item_834 in var_833 {
#[allow(unused_mut)]
let mut entry_836 = list_835.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_836, item_834)?;
}
list_835.finish();
}
#[allow(unused_mut)]
let mut scope_837 = writer.prefix("MaxRecords");
if let Some(var_838) = &input.max_records {
scope_837.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_838).into()),
);
}
#[allow(unused_mut)]
let mut scope_839 = writer.prefix("Marker");
if let Some(var_840) = &input.marker {
scope_839.string(var_840);
}
#[allow(unused_mut)]
let mut scope_841 = writer.prefix("DefaultOnly");
if input.default_only {
scope_841.boolean(input.default_only);
}
#[allow(unused_mut)]
let mut scope_842 = writer.prefix("ListSupportedCharacterSets");
if let Some(var_843) = &input.list_supported_character_sets {
scope_842.boolean(*var_843);
}
#[allow(unused_mut)]
let mut scope_844 = writer.prefix("ListSupportedTimezones");
if let Some(var_845) = &input.list_supported_timezones {
scope_844.boolean(*var_845);
}
#[allow(unused_mut)]
let mut scope_846 = writer.prefix("IncludeAll");
if let Some(var_847) = &input.include_all {
scope_846.boolean(*var_847);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_db_instance_automated_backups(
input: &crate::input::DescribeDbInstanceAutomatedBackupsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeDBInstanceAutomatedBackups",
"2014-10-31",
);
#[allow(unused_mut)]
let mut scope_848 = writer.prefix("DbiResourceId");
if let Some(var_849) = &input.dbi_resource_id {
scope_848.string(var_849);
}
#[allow(unused_mut)]
let mut scope_850 = writer.prefix("DBInstanceIdentifier");
if let Some(var_851) = &input.db_instance_identifier {
scope_850.string(var_851);
}
#[allow(unused_mut)]
let mut scope_852 = writer.prefix("Filters");
if let Some(var_853) = &input.filters {
let mut list_855 = scope_852.start_list(false, Some("Filter"));
for item_854 in var_853 {
#[allow(unused_mut)]
let mut entry_856 = list_855.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_856, item_854)?;
}
list_855.finish();
}
#[allow(unused_mut)]
let mut scope_857 = writer.prefix("MaxRecords");
if let Some(var_858) = &input.max_records {
scope_857.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_858).into()),
);
}
#[allow(unused_mut)]
let mut scope_859 = writer.prefix("Marker");
if let Some(var_860) = &input.marker {
scope_859.string(var_860);
}
#[allow(unused_mut)]
let mut scope_861 = writer.prefix("DBInstanceAutomatedBackupsArn");
if let Some(var_862) = &input.db_instance_automated_backups_arn {
scope_861.string(var_862);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_db_instances(
input: &crate::input::DescribeDbInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeDBInstances", "2014-10-31");
#[allow(unused_mut)]
let mut scope_863 = writer.prefix("DBInstanceIdentifier");
if let Some(var_864) = &input.db_instance_identifier {
scope_863.string(var_864);
}
#[allow(unused_mut)]
let mut scope_865 = writer.prefix("Filters");
if let Some(var_866) = &input.filters {
let mut list_868 = scope_865.start_list(false, Some("Filter"));
for item_867 in var_866 {
#[allow(unused_mut)]
let mut entry_869 = list_868.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_869, item_867)?;
}
list_868.finish();
}
#[allow(unused_mut)]
let mut scope_870 = writer.prefix("MaxRecords");
if let Some(var_871) = &input.max_records {
scope_870.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_871).into()),
);
}
#[allow(unused_mut)]
let mut scope_872 = writer.prefix("Marker");
if let Some(var_873) = &input.marker {
scope_872.string(var_873);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_db_log_files(
input: &crate::input::DescribeDbLogFilesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeDBLogFiles", "2014-10-31");
#[allow(unused_mut)]
let mut scope_874 = writer.prefix("DBInstanceIdentifier");
if let Some(var_875) = &input.db_instance_identifier {
scope_874.string(var_875);
}
#[allow(unused_mut)]
let mut scope_876 = writer.prefix("FilenameContains");
if let Some(var_877) = &input.filename_contains {
scope_876.string(var_877);
}
#[allow(unused_mut)]
let mut scope_878 = writer.prefix("FileLastWritten");
if input.file_last_written != 0 {
scope_878.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.file_last_written).into()),
);
}
#[allow(unused_mut)]
let mut scope_879 = writer.prefix("FileSize");
if input.file_size != 0 {
scope_879.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.file_size).into()),
);
}
#[allow(unused_mut)]
let mut scope_880 = writer.prefix("Filters");
if let Some(var_881) = &input.filters {
let mut list_883 = scope_880.start_list(false, Some("Filter"));
for item_882 in var_881 {
#[allow(unused_mut)]
let mut entry_884 = list_883.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_884, item_882)?;
}
list_883.finish();
}
#[allow(unused_mut)]
let mut scope_885 = writer.prefix("MaxRecords");
if let Some(var_886) = &input.max_records {
scope_885.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_886).into()),
);
}
#[allow(unused_mut)]
let mut scope_887 = writer.prefix("Marker");
if let Some(var_888) = &input.marker {
scope_887.string(var_888);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_db_parameter_groups(
input: &crate::input::DescribeDbParameterGroupsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeDBParameterGroups", "2014-10-31");
#[allow(unused_mut)]
let mut scope_889 = writer.prefix("DBParameterGroupName");
if let Some(var_890) = &input.db_parameter_group_name {
scope_889.string(var_890);
}
#[allow(unused_mut)]
let mut scope_891 = writer.prefix("Filters");
if let Some(var_892) = &input.filters {
let mut list_894 = scope_891.start_list(false, Some("Filter"));
for item_893 in var_892 {
#[allow(unused_mut)]
let mut entry_895 = list_894.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_895, item_893)?;
}
list_894.finish();
}
#[allow(unused_mut)]
let mut scope_896 = writer.prefix("MaxRecords");
if let Some(var_897) = &input.max_records {
scope_896.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_897).into()),
);
}
#[allow(unused_mut)]
let mut scope_898 = writer.prefix("Marker");
if let Some(var_899) = &input.marker {
scope_898.string(var_899);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_db_parameters(
input: &crate::input::DescribeDbParametersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeDBParameters", "2014-10-31");
#[allow(unused_mut)]
let mut scope_900 = writer.prefix("DBParameterGroupName");
if let Some(var_901) = &input.db_parameter_group_name {
scope_900.string(var_901);
}
#[allow(unused_mut)]
let mut scope_902 = writer.prefix("Source");
if let Some(var_903) = &input.source {
scope_902.string(var_903);
}
#[allow(unused_mut)]
let mut scope_904 = writer.prefix("Filters");
if let Some(var_905) = &input.filters {
let mut list_907 = scope_904.start_list(false, Some("Filter"));
for item_906 in var_905 {
#[allow(unused_mut)]
let mut entry_908 = list_907.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_908, item_906)?;
}
list_907.finish();
}
#[allow(unused_mut)]
let mut scope_909 = writer.prefix("MaxRecords");
if let Some(var_910) = &input.max_records {
scope_909.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_910).into()),
);
}
#[allow(unused_mut)]
let mut scope_911 = writer.prefix("Marker");
if let Some(var_912) = &input.marker {
scope_911.string(var_912);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_db_proxies(
input: &crate::input::DescribeDbProxiesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeDBProxies", "2014-10-31");
#[allow(unused_mut)]
let mut scope_913 = writer.prefix("DBProxyName");
if let Some(var_914) = &input.db_proxy_name {
scope_913.string(var_914);
}
#[allow(unused_mut)]
let mut scope_915 = writer.prefix("Filters");
if let Some(var_916) = &input.filters {
let mut list_918 = scope_915.start_list(false, Some("Filter"));
for item_917 in var_916 {
#[allow(unused_mut)]
let mut entry_919 = list_918.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_919, item_917)?;
}
list_918.finish();
}
#[allow(unused_mut)]
let mut scope_920 = writer.prefix("Marker");
if let Some(var_921) = &input.marker {
scope_920.string(var_921);
}
#[allow(unused_mut)]
let mut scope_922 = writer.prefix("MaxRecords");
if let Some(var_923) = &input.max_records {
scope_922.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_923).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_db_proxy_endpoints(
input: &crate::input::DescribeDbProxyEndpointsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeDBProxyEndpoints", "2014-10-31");
#[allow(unused_mut)]
let mut scope_924 = writer.prefix("DBProxyName");
if let Some(var_925) = &input.db_proxy_name {
scope_924.string(var_925);
}
#[allow(unused_mut)]
let mut scope_926 = writer.prefix("DBProxyEndpointName");
if let Some(var_927) = &input.db_proxy_endpoint_name {
scope_926.string(var_927);
}
#[allow(unused_mut)]
let mut scope_928 = writer.prefix("Filters");
if let Some(var_929) = &input.filters {
let mut list_931 = scope_928.start_list(false, Some("Filter"));
for item_930 in var_929 {
#[allow(unused_mut)]
let mut entry_932 = list_931.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_932, item_930)?;
}
list_931.finish();
}
#[allow(unused_mut)]
let mut scope_933 = writer.prefix("Marker");
if let Some(var_934) = &input.marker {
scope_933.string(var_934);
}
#[allow(unused_mut)]
let mut scope_935 = writer.prefix("MaxRecords");
if let Some(var_936) = &input.max_records {
scope_935.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_936).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_db_proxy_target_groups(
input: &crate::input::DescribeDbProxyTargetGroupsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeDBProxyTargetGroups", "2014-10-31");
#[allow(unused_mut)]
let mut scope_937 = writer.prefix("DBProxyName");
if let Some(var_938) = &input.db_proxy_name {
scope_937.string(var_938);
}
#[allow(unused_mut)]
let mut scope_939 = writer.prefix("TargetGroupName");
if let Some(var_940) = &input.target_group_name {
scope_939.string(var_940);
}
#[allow(unused_mut)]
let mut scope_941 = writer.prefix("Filters");
if let Some(var_942) = &input.filters {
let mut list_944 = scope_941.start_list(false, Some("Filter"));
for item_943 in var_942 {
#[allow(unused_mut)]
let mut entry_945 = list_944.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_945, item_943)?;
}
list_944.finish();
}
#[allow(unused_mut)]
let mut scope_946 = writer.prefix("Marker");
if let Some(var_947) = &input.marker {
scope_946.string(var_947);
}
#[allow(unused_mut)]
let mut scope_948 = writer.prefix("MaxRecords");
if let Some(var_949) = &input.max_records {
scope_948.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_949).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_db_proxy_targets(
input: &crate::input::DescribeDbProxyTargetsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeDBProxyTargets", "2014-10-31");
#[allow(unused_mut)]
let mut scope_950 = writer.prefix("DBProxyName");
if let Some(var_951) = &input.db_proxy_name {
scope_950.string(var_951);
}
#[allow(unused_mut)]
let mut scope_952 = writer.prefix("TargetGroupName");
if let Some(var_953) = &input.target_group_name {
scope_952.string(var_953);
}
#[allow(unused_mut)]
let mut scope_954 = writer.prefix("Filters");
if let Some(var_955) = &input.filters {
let mut list_957 = scope_954.start_list(false, Some("Filter"));
for item_956 in var_955 {
#[allow(unused_mut)]
let mut entry_958 = list_957.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_958, item_956)?;
}
list_957.finish();
}
#[allow(unused_mut)]
let mut scope_959 = writer.prefix("Marker");
if let Some(var_960) = &input.marker {
scope_959.string(var_960);
}
#[allow(unused_mut)]
let mut scope_961 = writer.prefix("MaxRecords");
if let Some(var_962) = &input.max_records {
scope_961.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_962).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_db_security_groups(
input: &crate::input::DescribeDbSecurityGroupsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeDBSecurityGroups", "2014-10-31");
#[allow(unused_mut)]
let mut scope_963 = writer.prefix("DBSecurityGroupName");
if let Some(var_964) = &input.db_security_group_name {
scope_963.string(var_964);
}
#[allow(unused_mut)]
let mut scope_965 = writer.prefix("Filters");
if let Some(var_966) = &input.filters {
let mut list_968 = scope_965.start_list(false, Some("Filter"));
for item_967 in var_966 {
#[allow(unused_mut)]
let mut entry_969 = list_968.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_969, item_967)?;
}
list_968.finish();
}
#[allow(unused_mut)]
let mut scope_970 = writer.prefix("MaxRecords");
if let Some(var_971) = &input.max_records {
scope_970.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_971).into()),
);
}
#[allow(unused_mut)]
let mut scope_972 = writer.prefix("Marker");
if let Some(var_973) = &input.marker {
scope_972.string(var_973);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_db_snapshot_attributes(
input: &crate::input::DescribeDbSnapshotAttributesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeDBSnapshotAttributes", "2014-10-31");
#[allow(unused_mut)]
let mut scope_974 = writer.prefix("DBSnapshotIdentifier");
if let Some(var_975) = &input.db_snapshot_identifier {
scope_974.string(var_975);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_db_snapshots(
input: &crate::input::DescribeDbSnapshotsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeDBSnapshots", "2014-10-31");
#[allow(unused_mut)]
let mut scope_976 = writer.prefix("DBInstanceIdentifier");
if let Some(var_977) = &input.db_instance_identifier {
scope_976.string(var_977);
}
#[allow(unused_mut)]
let mut scope_978 = writer.prefix("DBSnapshotIdentifier");
if let Some(var_979) = &input.db_snapshot_identifier {
scope_978.string(var_979);
}
#[allow(unused_mut)]
let mut scope_980 = writer.prefix("SnapshotType");
if let Some(var_981) = &input.snapshot_type {
scope_980.string(var_981);
}
#[allow(unused_mut)]
let mut scope_982 = writer.prefix("Filters");
if let Some(var_983) = &input.filters {
let mut list_985 = scope_982.start_list(false, Some("Filter"));
for item_984 in var_983 {
#[allow(unused_mut)]
let mut entry_986 = list_985.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_986, item_984)?;
}
list_985.finish();
}
#[allow(unused_mut)]
let mut scope_987 = writer.prefix("MaxRecords");
if let Some(var_988) = &input.max_records {
scope_987.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_988).into()),
);
}
#[allow(unused_mut)]
let mut scope_989 = writer.prefix("Marker");
if let Some(var_990) = &input.marker {
scope_989.string(var_990);
}
#[allow(unused_mut)]
let mut scope_991 = writer.prefix("IncludeShared");
if input.include_shared {
scope_991.boolean(input.include_shared);
}
#[allow(unused_mut)]
let mut scope_992 = writer.prefix("IncludePublic");
if input.include_public {
scope_992.boolean(input.include_public);
}
#[allow(unused_mut)]
let mut scope_993 = writer.prefix("DbiResourceId");
if let Some(var_994) = &input.dbi_resource_id {
scope_993.string(var_994);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_db_subnet_groups(
input: &crate::input::DescribeDbSubnetGroupsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeDBSubnetGroups", "2014-10-31");
#[allow(unused_mut)]
let mut scope_995 = writer.prefix("DBSubnetGroupName");
if let Some(var_996) = &input.db_subnet_group_name {
scope_995.string(var_996);
}
#[allow(unused_mut)]
let mut scope_997 = writer.prefix("Filters");
if let Some(var_998) = &input.filters {
let mut list_1000 = scope_997.start_list(false, Some("Filter"));
for item_999 in var_998 {
#[allow(unused_mut)]
let mut entry_1001 = list_1000.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_1001, item_999)?;
}
list_1000.finish();
}
#[allow(unused_mut)]
let mut scope_1002 = writer.prefix("MaxRecords");
if let Some(var_1003) = &input.max_records {
scope_1002.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1003).into()),
);
}
#[allow(unused_mut)]
let mut scope_1004 = writer.prefix("Marker");
if let Some(var_1005) = &input.marker {
scope_1004.string(var_1005);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_engine_default_cluster_parameters(
input: &crate::input::DescribeEngineDefaultClusterParametersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeEngineDefaultClusterParameters",
"2014-10-31",
);
#[allow(unused_mut)]
let mut scope_1006 = writer.prefix("DBParameterGroupFamily");
if let Some(var_1007) = &input.db_parameter_group_family {
scope_1006.string(var_1007);
}
#[allow(unused_mut)]
let mut scope_1008 = writer.prefix("Filters");
if let Some(var_1009) = &input.filters {
let mut list_1011 = scope_1008.start_list(false, Some("Filter"));
for item_1010 in var_1009 {
#[allow(unused_mut)]
let mut entry_1012 = list_1011.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_1012, item_1010)?;
}
list_1011.finish();
}
#[allow(unused_mut)]
let mut scope_1013 = writer.prefix("MaxRecords");
if let Some(var_1014) = &input.max_records {
scope_1013.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1014).into()),
);
}
#[allow(unused_mut)]
let mut scope_1015 = writer.prefix("Marker");
if let Some(var_1016) = &input.marker {
scope_1015.string(var_1016);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_engine_default_parameters(
input: &crate::input::DescribeEngineDefaultParametersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeEngineDefaultParameters",
"2014-10-31",
);
#[allow(unused_mut)]
let mut scope_1017 = writer.prefix("DBParameterGroupFamily");
if let Some(var_1018) = &input.db_parameter_group_family {
scope_1017.string(var_1018);
}
#[allow(unused_mut)]
let mut scope_1019 = writer.prefix("Filters");
if let Some(var_1020) = &input.filters {
let mut list_1022 = scope_1019.start_list(false, Some("Filter"));
for item_1021 in var_1020 {
#[allow(unused_mut)]
let mut entry_1023 = list_1022.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_1023, item_1021)?;
}
list_1022.finish();
}
#[allow(unused_mut)]
let mut scope_1024 = writer.prefix("MaxRecords");
if let Some(var_1025) = &input.max_records {
scope_1024.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1025).into()),
);
}
#[allow(unused_mut)]
let mut scope_1026 = writer.prefix("Marker");
if let Some(var_1027) = &input.marker {
scope_1026.string(var_1027);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_event_categories(
input: &crate::input::DescribeEventCategoriesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeEventCategories", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1028 = writer.prefix("SourceType");
if let Some(var_1029) = &input.source_type {
scope_1028.string(var_1029);
}
#[allow(unused_mut)]
let mut scope_1030 = writer.prefix("Filters");
if let Some(var_1031) = &input.filters {
let mut list_1033 = scope_1030.start_list(false, Some("Filter"));
for item_1032 in var_1031 {
#[allow(unused_mut)]
let mut entry_1034 = list_1033.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_1034, item_1032)?;
}
list_1033.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_events(
input: &crate::input::DescribeEventsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeEvents", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1035 = writer.prefix("SourceIdentifier");
if let Some(var_1036) = &input.source_identifier {
scope_1035.string(var_1036);
}
#[allow(unused_mut)]
let mut scope_1037 = writer.prefix("SourceType");
if let Some(var_1038) = &input.source_type {
scope_1037.string(var_1038.as_str());
}
#[allow(unused_mut)]
let mut scope_1039 = writer.prefix("StartTime");
if let Some(var_1040) = &input.start_time {
scope_1039.date_time(var_1040, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_1041 = writer.prefix("EndTime");
if let Some(var_1042) = &input.end_time {
scope_1041.date_time(var_1042, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_1043 = writer.prefix("Duration");
if let Some(var_1044) = &input.duration {
scope_1043.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1044).into()),
);
}
#[allow(unused_mut)]
let mut scope_1045 = writer.prefix("EventCategories");
if let Some(var_1046) = &input.event_categories {
let mut list_1048 = scope_1045.start_list(false, Some("EventCategory"));
for item_1047 in var_1046 {
#[allow(unused_mut)]
let mut entry_1049 = list_1048.entry();
entry_1049.string(item_1047);
}
list_1048.finish();
}
#[allow(unused_mut)]
let mut scope_1050 = writer.prefix("Filters");
if let Some(var_1051) = &input.filters {
let mut list_1053 = scope_1050.start_list(false, Some("Filter"));
for item_1052 in var_1051 {
#[allow(unused_mut)]
let mut entry_1054 = list_1053.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_1054, item_1052)?;
}
list_1053.finish();
}
#[allow(unused_mut)]
let mut scope_1055 = writer.prefix("MaxRecords");
if let Some(var_1056) = &input.max_records {
scope_1055.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1056).into()),
);
}
#[allow(unused_mut)]
let mut scope_1057 = writer.prefix("Marker");
if let Some(var_1058) = &input.marker {
scope_1057.string(var_1058);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_event_subscriptions(
input: &crate::input::DescribeEventSubscriptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeEventSubscriptions", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1059 = writer.prefix("SubscriptionName");
if let Some(var_1060) = &input.subscription_name {
scope_1059.string(var_1060);
}
#[allow(unused_mut)]
let mut scope_1061 = writer.prefix("Filters");
if let Some(var_1062) = &input.filters {
let mut list_1064 = scope_1061.start_list(false, Some("Filter"));
for item_1063 in var_1062 {
#[allow(unused_mut)]
let mut entry_1065 = list_1064.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_1065, item_1063)?;
}
list_1064.finish();
}
#[allow(unused_mut)]
let mut scope_1066 = writer.prefix("MaxRecords");
if let Some(var_1067) = &input.max_records {
scope_1066.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1067).into()),
);
}
#[allow(unused_mut)]
let mut scope_1068 = writer.prefix("Marker");
if let Some(var_1069) = &input.marker {
scope_1068.string(var_1069);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_export_tasks(
input: &crate::input::DescribeExportTasksInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeExportTasks", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1070 = writer.prefix("ExportTaskIdentifier");
if let Some(var_1071) = &input.export_task_identifier {
scope_1070.string(var_1071);
}
#[allow(unused_mut)]
let mut scope_1072 = writer.prefix("SourceArn");
if let Some(var_1073) = &input.source_arn {
scope_1072.string(var_1073);
}
#[allow(unused_mut)]
let mut scope_1074 = writer.prefix("Filters");
if let Some(var_1075) = &input.filters {
let mut list_1077 = scope_1074.start_list(false, Some("Filter"));
for item_1076 in var_1075 {
#[allow(unused_mut)]
let mut entry_1078 = list_1077.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_1078, item_1076)?;
}
list_1077.finish();
}
#[allow(unused_mut)]
let mut scope_1079 = writer.prefix("Marker");
if let Some(var_1080) = &input.marker {
scope_1079.string(var_1080);
}
#[allow(unused_mut)]
let mut scope_1081 = writer.prefix("MaxRecords");
if let Some(var_1082) = &input.max_records {
scope_1081.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1082).into()),
);
}
#[allow(unused_mut)]
let mut scope_1083 = writer.prefix("SourceType");
if let Some(var_1084) = &input.source_type {
scope_1083.string(var_1084.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_global_clusters(
input: &crate::input::DescribeGlobalClustersInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeGlobalClusters", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1085 = writer.prefix("GlobalClusterIdentifier");
if let Some(var_1086) = &input.global_cluster_identifier {
scope_1085.string(var_1086);
}
#[allow(unused_mut)]
let mut scope_1087 = writer.prefix("Filters");
if let Some(var_1088) = &input.filters {
let mut list_1090 = scope_1087.start_list(false, Some("Filter"));
for item_1089 in var_1088 {
#[allow(unused_mut)]
let mut entry_1091 = list_1090.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_1091, item_1089)?;
}
list_1090.finish();
}
#[allow(unused_mut)]
let mut scope_1092 = writer.prefix("MaxRecords");
if let Some(var_1093) = &input.max_records {
scope_1092.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1093).into()),
);
}
#[allow(unused_mut)]
let mut scope_1094 = writer.prefix("Marker");
if let Some(var_1095) = &input.marker {
scope_1094.string(var_1095);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_option_group_options(
input: &crate::input::DescribeOptionGroupOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeOptionGroupOptions", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1096 = writer.prefix("EngineName");
if let Some(var_1097) = &input.engine_name {
scope_1096.string(var_1097);
}
#[allow(unused_mut)]
let mut scope_1098 = writer.prefix("MajorEngineVersion");
if let Some(var_1099) = &input.major_engine_version {
scope_1098.string(var_1099);
}
#[allow(unused_mut)]
let mut scope_1100 = writer.prefix("Filters");
if let Some(var_1101) = &input.filters {
let mut list_1103 = scope_1100.start_list(false, Some("Filter"));
for item_1102 in var_1101 {
#[allow(unused_mut)]
let mut entry_1104 = list_1103.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_1104, item_1102)?;
}
list_1103.finish();
}
#[allow(unused_mut)]
let mut scope_1105 = writer.prefix("MaxRecords");
if let Some(var_1106) = &input.max_records {
scope_1105.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1106).into()),
);
}
#[allow(unused_mut)]
let mut scope_1107 = writer.prefix("Marker");
if let Some(var_1108) = &input.marker {
scope_1107.string(var_1108);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_option_groups(
input: &crate::input::DescribeOptionGroupsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeOptionGroups", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1109 = writer.prefix("OptionGroupName");
if let Some(var_1110) = &input.option_group_name {
scope_1109.string(var_1110);
}
#[allow(unused_mut)]
let mut scope_1111 = writer.prefix("Filters");
if let Some(var_1112) = &input.filters {
let mut list_1114 = scope_1111.start_list(false, Some("Filter"));
for item_1113 in var_1112 {
#[allow(unused_mut)]
let mut entry_1115 = list_1114.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_1115, item_1113)?;
}
list_1114.finish();
}
#[allow(unused_mut)]
let mut scope_1116 = writer.prefix("Marker");
if let Some(var_1117) = &input.marker {
scope_1116.string(var_1117);
}
#[allow(unused_mut)]
let mut scope_1118 = writer.prefix("MaxRecords");
if let Some(var_1119) = &input.max_records {
scope_1118.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1119).into()),
);
}
#[allow(unused_mut)]
let mut scope_1120 = writer.prefix("EngineName");
if let Some(var_1121) = &input.engine_name {
scope_1120.string(var_1121);
}
#[allow(unused_mut)]
let mut scope_1122 = writer.prefix("MajorEngineVersion");
if let Some(var_1123) = &input.major_engine_version {
scope_1122.string(var_1123);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_orderable_db_instance_options(
input: &crate::input::DescribeOrderableDbInstanceOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeOrderableDBInstanceOptions",
"2014-10-31",
);
#[allow(unused_mut)]
let mut scope_1124 = writer.prefix("Engine");
if let Some(var_1125) = &input.engine {
scope_1124.string(var_1125);
}
#[allow(unused_mut)]
let mut scope_1126 = writer.prefix("EngineVersion");
if let Some(var_1127) = &input.engine_version {
scope_1126.string(var_1127);
}
#[allow(unused_mut)]
let mut scope_1128 = writer.prefix("DBInstanceClass");
if let Some(var_1129) = &input.db_instance_class {
scope_1128.string(var_1129);
}
#[allow(unused_mut)]
let mut scope_1130 = writer.prefix("LicenseModel");
if let Some(var_1131) = &input.license_model {
scope_1130.string(var_1131);
}
#[allow(unused_mut)]
let mut scope_1132 = writer.prefix("AvailabilityZoneGroup");
if let Some(var_1133) = &input.availability_zone_group {
scope_1132.string(var_1133);
}
#[allow(unused_mut)]
let mut scope_1134 = writer.prefix("Vpc");
if let Some(var_1135) = &input.vpc {
scope_1134.boolean(*var_1135);
}
#[allow(unused_mut)]
let mut scope_1136 = writer.prefix("Filters");
if let Some(var_1137) = &input.filters {
let mut list_1139 = scope_1136.start_list(false, Some("Filter"));
for item_1138 in var_1137 {
#[allow(unused_mut)]
let mut entry_1140 = list_1139.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_1140, item_1138)?;
}
list_1139.finish();
}
#[allow(unused_mut)]
let mut scope_1141 = writer.prefix("MaxRecords");
if let Some(var_1142) = &input.max_records {
scope_1141.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1142).into()),
);
}
#[allow(unused_mut)]
let mut scope_1143 = writer.prefix("Marker");
if let Some(var_1144) = &input.marker {
scope_1143.string(var_1144);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_pending_maintenance_actions(
input: &crate::input::DescribePendingMaintenanceActionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribePendingMaintenanceActions",
"2014-10-31",
);
#[allow(unused_mut)]
let mut scope_1145 = writer.prefix("ResourceIdentifier");
if let Some(var_1146) = &input.resource_identifier {
scope_1145.string(var_1146);
}
#[allow(unused_mut)]
let mut scope_1147 = writer.prefix("Filters");
if let Some(var_1148) = &input.filters {
let mut list_1150 = scope_1147.start_list(false, Some("Filter"));
for item_1149 in var_1148 {
#[allow(unused_mut)]
let mut entry_1151 = list_1150.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_1151, item_1149)?;
}
list_1150.finish();
}
#[allow(unused_mut)]
let mut scope_1152 = writer.prefix("Marker");
if let Some(var_1153) = &input.marker {
scope_1152.string(var_1153);
}
#[allow(unused_mut)]
let mut scope_1154 = writer.prefix("MaxRecords");
if let Some(var_1155) = &input.max_records {
scope_1154.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1155).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_reserved_db_instances(
input: &crate::input::DescribeReservedDbInstancesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeReservedDBInstances", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1156 = writer.prefix("ReservedDBInstanceId");
if let Some(var_1157) = &input.reserved_db_instance_id {
scope_1156.string(var_1157);
}
#[allow(unused_mut)]
let mut scope_1158 = writer.prefix("ReservedDBInstancesOfferingId");
if let Some(var_1159) = &input.reserved_db_instances_offering_id {
scope_1158.string(var_1159);
}
#[allow(unused_mut)]
let mut scope_1160 = writer.prefix("DBInstanceClass");
if let Some(var_1161) = &input.db_instance_class {
scope_1160.string(var_1161);
}
#[allow(unused_mut)]
let mut scope_1162 = writer.prefix("Duration");
if let Some(var_1163) = &input.duration {
scope_1162.string(var_1163);
}
#[allow(unused_mut)]
let mut scope_1164 = writer.prefix("ProductDescription");
if let Some(var_1165) = &input.product_description {
scope_1164.string(var_1165);
}
#[allow(unused_mut)]
let mut scope_1166 = writer.prefix("OfferingType");
if let Some(var_1167) = &input.offering_type {
scope_1166.string(var_1167);
}
#[allow(unused_mut)]
let mut scope_1168 = writer.prefix("MultiAZ");
if let Some(var_1169) = &input.multi_az {
scope_1168.boolean(*var_1169);
}
#[allow(unused_mut)]
let mut scope_1170 = writer.prefix("LeaseId");
if let Some(var_1171) = &input.lease_id {
scope_1170.string(var_1171);
}
#[allow(unused_mut)]
let mut scope_1172 = writer.prefix("Filters");
if let Some(var_1173) = &input.filters {
let mut list_1175 = scope_1172.start_list(false, Some("Filter"));
for item_1174 in var_1173 {
#[allow(unused_mut)]
let mut entry_1176 = list_1175.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_1176, item_1174)?;
}
list_1175.finish();
}
#[allow(unused_mut)]
let mut scope_1177 = writer.prefix("MaxRecords");
if let Some(var_1178) = &input.max_records {
scope_1177.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1178).into()),
);
}
#[allow(unused_mut)]
let mut scope_1179 = writer.prefix("Marker");
if let Some(var_1180) = &input.marker {
scope_1179.string(var_1180);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_reserved_db_instances_offerings(
input: &crate::input::DescribeReservedDbInstancesOfferingsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeReservedDBInstancesOfferings",
"2014-10-31",
);
#[allow(unused_mut)]
let mut scope_1181 = writer.prefix("ReservedDBInstancesOfferingId");
if let Some(var_1182) = &input.reserved_db_instances_offering_id {
scope_1181.string(var_1182);
}
#[allow(unused_mut)]
let mut scope_1183 = writer.prefix("DBInstanceClass");
if let Some(var_1184) = &input.db_instance_class {
scope_1183.string(var_1184);
}
#[allow(unused_mut)]
let mut scope_1185 = writer.prefix("Duration");
if let Some(var_1186) = &input.duration {
scope_1185.string(var_1186);
}
#[allow(unused_mut)]
let mut scope_1187 = writer.prefix("ProductDescription");
if let Some(var_1188) = &input.product_description {
scope_1187.string(var_1188);
}
#[allow(unused_mut)]
let mut scope_1189 = writer.prefix("OfferingType");
if let Some(var_1190) = &input.offering_type {
scope_1189.string(var_1190);
}
#[allow(unused_mut)]
let mut scope_1191 = writer.prefix("MultiAZ");
if let Some(var_1192) = &input.multi_az {
scope_1191.boolean(*var_1192);
}
#[allow(unused_mut)]
let mut scope_1193 = writer.prefix("Filters");
if let Some(var_1194) = &input.filters {
let mut list_1196 = scope_1193.start_list(false, Some("Filter"));
for item_1195 in var_1194 {
#[allow(unused_mut)]
let mut entry_1197 = list_1196.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_1197, item_1195)?;
}
list_1196.finish();
}
#[allow(unused_mut)]
let mut scope_1198 = writer.prefix("MaxRecords");
if let Some(var_1199) = &input.max_records {
scope_1198.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1199).into()),
);
}
#[allow(unused_mut)]
let mut scope_1200 = writer.prefix("Marker");
if let Some(var_1201) = &input.marker {
scope_1200.string(var_1201);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_source_regions(
input: &crate::input::DescribeSourceRegionsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeSourceRegions", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1202 = writer.prefix("RegionName");
if let Some(var_1203) = &input.region_name {
scope_1202.string(var_1203);
}
#[allow(unused_mut)]
let mut scope_1204 = writer.prefix("MaxRecords");
if let Some(var_1205) = &input.max_records {
scope_1204.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1205).into()),
);
}
#[allow(unused_mut)]
let mut scope_1206 = writer.prefix("Marker");
if let Some(var_1207) = &input.marker {
scope_1206.string(var_1207);
}
#[allow(unused_mut)]
let mut scope_1208 = writer.prefix("Filters");
if let Some(var_1209) = &input.filters {
let mut list_1211 = scope_1208.start_list(false, Some("Filter"));
for item_1210 in var_1209 {
#[allow(unused_mut)]
let mut entry_1212 = list_1211.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_1212, item_1210)?;
}
list_1211.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_valid_db_instance_modifications(
input: &crate::input::DescribeValidDbInstanceModificationsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeValidDBInstanceModifications",
"2014-10-31",
);
#[allow(unused_mut)]
let mut scope_1213 = writer.prefix("DBInstanceIdentifier");
if let Some(var_1214) = &input.db_instance_identifier {
scope_1213.string(var_1214);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_download_db_log_file_portion(
input: &crate::input::DownloadDbLogFilePortionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DownloadDBLogFilePortion", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1215 = writer.prefix("DBInstanceIdentifier");
if let Some(var_1216) = &input.db_instance_identifier {
scope_1215.string(var_1216);
}
#[allow(unused_mut)]
let mut scope_1217 = writer.prefix("LogFileName");
if let Some(var_1218) = &input.log_file_name {
scope_1217.string(var_1218);
}
#[allow(unused_mut)]
let mut scope_1219 = writer.prefix("Marker");
if let Some(var_1220) = &input.marker {
scope_1219.string(var_1220);
}
#[allow(unused_mut)]
let mut scope_1221 = writer.prefix("NumberOfLines");
if input.number_of_lines != 0 {
scope_1221.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.number_of_lines).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_failover_db_cluster(
input: &crate::input::FailoverDbClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "FailoverDBCluster", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1222 = writer.prefix("DBClusterIdentifier");
if let Some(var_1223) = &input.db_cluster_identifier {
scope_1222.string(var_1223);
}
#[allow(unused_mut)]
let mut scope_1224 = writer.prefix("TargetDBInstanceIdentifier");
if let Some(var_1225) = &input.target_db_instance_identifier {
scope_1224.string(var_1225);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_failover_global_cluster(
input: &crate::input::FailoverGlobalClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "FailoverGlobalCluster", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1226 = writer.prefix("GlobalClusterIdentifier");
if let Some(var_1227) = &input.global_cluster_identifier {
scope_1226.string(var_1227);
}
#[allow(unused_mut)]
let mut scope_1228 = writer.prefix("TargetDbClusterIdentifier");
if let Some(var_1229) = &input.target_db_cluster_identifier {
scope_1228.string(var_1229);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_list_tags_for_resource(
input: &crate::input::ListTagsForResourceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ListTagsForResource", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1230 = writer.prefix("ResourceName");
if let Some(var_1231) = &input.resource_name {
scope_1230.string(var_1231);
}
#[allow(unused_mut)]
let mut scope_1232 = writer.prefix("Filters");
if let Some(var_1233) = &input.filters {
let mut list_1235 = scope_1232.start_list(false, Some("Filter"));
for item_1234 in var_1233 {
#[allow(unused_mut)]
let mut entry_1236 = list_1235.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_1236, item_1234)?;
}
list_1235.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_activity_stream(
input: &crate::input::ModifyActivityStreamInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyActivityStream", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1237 = writer.prefix("ResourceArn");
if let Some(var_1238) = &input.resource_arn {
scope_1237.string(var_1238);
}
#[allow(unused_mut)]
let mut scope_1239 = writer.prefix("AuditPolicyState");
if let Some(var_1240) = &input.audit_policy_state {
scope_1239.string(var_1240.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_certificates(
input: &crate::input::ModifyCertificatesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyCertificates", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1241 = writer.prefix("CertificateIdentifier");
if let Some(var_1242) = &input.certificate_identifier {
scope_1241.string(var_1242);
}
#[allow(unused_mut)]
let mut scope_1243 = writer.prefix("RemoveCustomerOverride");
if let Some(var_1244) = &input.remove_customer_override {
scope_1243.boolean(*var_1244);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_current_db_cluster_capacity(
input: &crate::input::ModifyCurrentDbClusterCapacityInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ModifyCurrentDBClusterCapacity",
"2014-10-31",
);
#[allow(unused_mut)]
let mut scope_1245 = writer.prefix("DBClusterIdentifier");
if let Some(var_1246) = &input.db_cluster_identifier {
scope_1245.string(var_1246);
}
#[allow(unused_mut)]
let mut scope_1247 = writer.prefix("Capacity");
if let Some(var_1248) = &input.capacity {
scope_1247.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1248).into()),
);
}
#[allow(unused_mut)]
let mut scope_1249 = writer.prefix("SecondsBeforeTimeout");
if let Some(var_1250) = &input.seconds_before_timeout {
scope_1249.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1250).into()),
);
}
#[allow(unused_mut)]
let mut scope_1251 = writer.prefix("TimeoutAction");
if let Some(var_1252) = &input.timeout_action {
scope_1251.string(var_1252);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_custom_db_engine_version(
input: &crate::input::ModifyCustomDbEngineVersionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyCustomDBEngineVersion", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1253 = writer.prefix("Engine");
if let Some(var_1254) = &input.engine {
scope_1253.string(var_1254);
}
#[allow(unused_mut)]
let mut scope_1255 = writer.prefix("EngineVersion");
if let Some(var_1256) = &input.engine_version {
scope_1255.string(var_1256);
}
#[allow(unused_mut)]
let mut scope_1257 = writer.prefix("Description");
if let Some(var_1258) = &input.description {
scope_1257.string(var_1258);
}
#[allow(unused_mut)]
let mut scope_1259 = writer.prefix("Status");
if let Some(var_1260) = &input.status {
scope_1259.string(var_1260.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_db_cluster(
input: &crate::input::ModifyDbClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ModifyDBCluster", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1261 = writer.prefix("DBClusterIdentifier");
if let Some(var_1262) = &input.db_cluster_identifier {
scope_1261.string(var_1262);
}
#[allow(unused_mut)]
let mut scope_1263 = writer.prefix("NewDBClusterIdentifier");
if let Some(var_1264) = &input.new_db_cluster_identifier {
scope_1263.string(var_1264);
}
#[allow(unused_mut)]
let mut scope_1265 = writer.prefix("ApplyImmediately");
if input.apply_immediately {
scope_1265.boolean(input.apply_immediately);
}
#[allow(unused_mut)]
let mut scope_1266 = writer.prefix("BackupRetentionPeriod");
if let Some(var_1267) = &input.backup_retention_period {
scope_1266.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1267).into()),
);
}
#[allow(unused_mut)]
let mut scope_1268 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_1269) = &input.db_cluster_parameter_group_name {
scope_1268.string(var_1269);
}
#[allow(unused_mut)]
let mut scope_1270 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_1271) = &input.vpc_security_group_ids {
let mut list_1273 = scope_1270.start_list(false, Some("VpcSecurityGroupId"));
for item_1272 in var_1271 {
#[allow(unused_mut)]
let mut entry_1274 = list_1273.entry();
entry_1274.string(item_1272);
}
list_1273.finish();
}
#[allow(unused_mut)]
let mut scope_1275 = writer.prefix("Port");
if let Some(var_1276) = &input.port {
scope_1275.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1276).into()),
);
}
#[allow(unused_mut)]
let mut scope_1277 = writer.prefix("MasterUserPassword");
if let Some(var_1278) = &input.master_user_password {
scope_1277.string(var_1278);
}
#[allow(unused_mut)]
let mut scope_1279 = writer.prefix("OptionGroupName");
if let Some(var_1280) = &input.option_group_name {
scope_1279.string(var_1280);
}
#[allow(unused_mut)]
let mut scope_1281 = writer.prefix("PreferredBackupWindow");
if let Some(var_1282) = &input.preferred_backup_window {
scope_1281.string(var_1282);
}
#[allow(unused_mut)]
let mut scope_1283 = writer.prefix("PreferredMaintenanceWindow");
if let Some(var_1284) = &input.preferred_maintenance_window {
scope_1283.string(var_1284);
}
#[allow(unused_mut)]
let mut scope_1285 = writer.prefix("EnableIAMDatabaseAuthentication");
if let Some(var_1286) = &input.enable_iam_database_authentication {
scope_1285.boolean(*var_1286);
}
#[allow(unused_mut)]
let mut scope_1287 = writer.prefix("BacktrackWindow");
if let Some(var_1288) = &input.backtrack_window {
scope_1287.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1288).into()),
);
}
#[allow(unused_mut)]
let mut scope_1289 = writer.prefix("CloudwatchLogsExportConfiguration");
if let Some(var_1290) = &input.cloudwatch_logs_export_configuration {
crate::query_ser::serialize_structure_crate_model_cloudwatch_logs_export_configuration(
scope_1289, var_1290,
)?;
}
#[allow(unused_mut)]
let mut scope_1291 = writer.prefix("EngineVersion");
if let Some(var_1292) = &input.engine_version {
scope_1291.string(var_1292);
}
#[allow(unused_mut)]
let mut scope_1293 = writer.prefix("AllowMajorVersionUpgrade");
if input.allow_major_version_upgrade {
scope_1293.boolean(input.allow_major_version_upgrade);
}
#[allow(unused_mut)]
let mut scope_1294 = writer.prefix("DBInstanceParameterGroupName");
if let Some(var_1295) = &input.db_instance_parameter_group_name {
scope_1294.string(var_1295);
}
#[allow(unused_mut)]
let mut scope_1296 = writer.prefix("Domain");
if let Some(var_1297) = &input.domain {
scope_1296.string(var_1297);
}
#[allow(unused_mut)]
let mut scope_1298 = writer.prefix("DomainIAMRoleName");
if let Some(var_1299) = &input.domain_iam_role_name {
scope_1298.string(var_1299);
}
#[allow(unused_mut)]
let mut scope_1300 = writer.prefix("ScalingConfiguration");
if let Some(var_1301) = &input.scaling_configuration {
crate::query_ser::serialize_structure_crate_model_scaling_configuration(
scope_1300, var_1301,
)?;
}
#[allow(unused_mut)]
let mut scope_1302 = writer.prefix("DeletionProtection");
if let Some(var_1303) = &input.deletion_protection {
scope_1302.boolean(*var_1303);
}
#[allow(unused_mut)]
let mut scope_1304 = writer.prefix("EnableHttpEndpoint");
if let Some(var_1305) = &input.enable_http_endpoint {
scope_1304.boolean(*var_1305);
}
#[allow(unused_mut)]
let mut scope_1306 = writer.prefix("CopyTagsToSnapshot");
if let Some(var_1307) = &input.copy_tags_to_snapshot {
scope_1306.boolean(*var_1307);
}
#[allow(unused_mut)]
let mut scope_1308 = writer.prefix("EnableGlobalWriteForwarding");
if let Some(var_1309) = &input.enable_global_write_forwarding {
scope_1308.boolean(*var_1309);
}
#[allow(unused_mut)]
let mut scope_1310 = writer.prefix("DBClusterInstanceClass");
if let Some(var_1311) = &input.db_cluster_instance_class {
scope_1310.string(var_1311);
}
#[allow(unused_mut)]
let mut scope_1312 = writer.prefix("AllocatedStorage");
if let Some(var_1313) = &input.allocated_storage {
scope_1312.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1313).into()),
);
}
#[allow(unused_mut)]
let mut scope_1314 = writer.prefix("StorageType");
if let Some(var_1315) = &input.storage_type {
scope_1314.string(var_1315);
}
#[allow(unused_mut)]
let mut scope_1316 = writer.prefix("Iops");
if let Some(var_1317) = &input.iops {
scope_1316.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1317).into()),
);
}
#[allow(unused_mut)]
let mut scope_1318 = writer.prefix("AutoMinorVersionUpgrade");
if let Some(var_1319) = &input.auto_minor_version_upgrade {
scope_1318.boolean(*var_1319);
}
#[allow(unused_mut)]
let mut scope_1320 = writer.prefix("MonitoringInterval");
if let Some(var_1321) = &input.monitoring_interval {
scope_1320.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1321).into()),
);
}
#[allow(unused_mut)]
let mut scope_1322 = writer.prefix("MonitoringRoleArn");
if let Some(var_1323) = &input.monitoring_role_arn {
scope_1322.string(var_1323);
}
#[allow(unused_mut)]
let mut scope_1324 = writer.prefix("EnablePerformanceInsights");
if let Some(var_1325) = &input.enable_performance_insights {
scope_1324.boolean(*var_1325);
}
#[allow(unused_mut)]
let mut scope_1326 = writer.prefix("PerformanceInsightsKMSKeyId");
if let Some(var_1327) = &input.performance_insights_kms_key_id {
scope_1326.string(var_1327);
}
#[allow(unused_mut)]
let mut scope_1328 = writer.prefix("PerformanceInsightsRetentionPeriod");
if let Some(var_1329) = &input.performance_insights_retention_period {
scope_1328.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1329).into()),
);
}
#[allow(unused_mut)]
let mut scope_1330 = writer.prefix("ServerlessV2ScalingConfiguration");
if let Some(var_1331) = &input.serverless_v2_scaling_configuration {
crate::query_ser::serialize_structure_crate_model_serverless_v2_scaling_configuration(
scope_1330, var_1331,
)?;
}
#[allow(unused_mut)]
let mut scope_1332 = writer.prefix("NetworkType");
if let Some(var_1333) = &input.network_type {
scope_1332.string(var_1333);
}
#[allow(unused_mut)]
let mut scope_1334 = writer.prefix("ManageMasterUserPassword");
if let Some(var_1335) = &input.manage_master_user_password {
scope_1334.boolean(*var_1335);
}
#[allow(unused_mut)]
let mut scope_1336 = writer.prefix("RotateMasterUserPassword");
if let Some(var_1337) = &input.rotate_master_user_password {
scope_1336.boolean(*var_1337);
}
#[allow(unused_mut)]
let mut scope_1338 = writer.prefix("MasterUserSecretKmsKeyId");
if let Some(var_1339) = &input.master_user_secret_kms_key_id {
scope_1338.string(var_1339);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_db_cluster_endpoint(
input: &crate::input::ModifyDbClusterEndpointInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyDBClusterEndpoint", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1340 = writer.prefix("DBClusterEndpointIdentifier");
if let Some(var_1341) = &input.db_cluster_endpoint_identifier {
scope_1340.string(var_1341);
}
#[allow(unused_mut)]
let mut scope_1342 = writer.prefix("EndpointType");
if let Some(var_1343) = &input.endpoint_type {
scope_1342.string(var_1343);
}
#[allow(unused_mut)]
let mut scope_1344 = writer.prefix("StaticMembers");
if let Some(var_1345) = &input.static_members {
let mut list_1347 = scope_1344.start_list(false, None);
for item_1346 in var_1345 {
#[allow(unused_mut)]
let mut entry_1348 = list_1347.entry();
entry_1348.string(item_1346);
}
list_1347.finish();
}
#[allow(unused_mut)]
let mut scope_1349 = writer.prefix("ExcludedMembers");
if let Some(var_1350) = &input.excluded_members {
let mut list_1352 = scope_1349.start_list(false, None);
for item_1351 in var_1350 {
#[allow(unused_mut)]
let mut entry_1353 = list_1352.entry();
entry_1353.string(item_1351);
}
list_1352.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_db_cluster_parameter_group(
input: &crate::input::ModifyDbClusterParameterGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyDBClusterParameterGroup", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1354 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_1355) = &input.db_cluster_parameter_group_name {
scope_1354.string(var_1355);
}
#[allow(unused_mut)]
let mut scope_1356 = writer.prefix("Parameters");
if let Some(var_1357) = &input.parameters {
let mut list_1359 = scope_1356.start_list(false, Some("Parameter"));
for item_1358 in var_1357 {
#[allow(unused_mut)]
let mut entry_1360 = list_1359.entry();
crate::query_ser::serialize_structure_crate_model_parameter(entry_1360, item_1358)?;
}
list_1359.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_db_cluster_snapshot_attribute(
input: &crate::input::ModifyDbClusterSnapshotAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ModifyDBClusterSnapshotAttribute",
"2014-10-31",
);
#[allow(unused_mut)]
let mut scope_1361 = writer.prefix("DBClusterSnapshotIdentifier");
if let Some(var_1362) = &input.db_cluster_snapshot_identifier {
scope_1361.string(var_1362);
}
#[allow(unused_mut)]
let mut scope_1363 = writer.prefix("AttributeName");
if let Some(var_1364) = &input.attribute_name {
scope_1363.string(var_1364);
}
#[allow(unused_mut)]
let mut scope_1365 = writer.prefix("ValuesToAdd");
if let Some(var_1366) = &input.values_to_add {
let mut list_1368 = scope_1365.start_list(false, Some("AttributeValue"));
for item_1367 in var_1366 {
#[allow(unused_mut)]
let mut entry_1369 = list_1368.entry();
entry_1369.string(item_1367);
}
list_1368.finish();
}
#[allow(unused_mut)]
let mut scope_1370 = writer.prefix("ValuesToRemove");
if let Some(var_1371) = &input.values_to_remove {
let mut list_1373 = scope_1370.start_list(false, Some("AttributeValue"));
for item_1372 in var_1371 {
#[allow(unused_mut)]
let mut entry_1374 = list_1373.entry();
entry_1374.string(item_1372);
}
list_1373.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_db_instance(
input: &crate::input::ModifyDbInstanceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ModifyDBInstance", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1375 = writer.prefix("DBInstanceIdentifier");
if let Some(var_1376) = &input.db_instance_identifier {
scope_1375.string(var_1376);
}
#[allow(unused_mut)]
let mut scope_1377 = writer.prefix("AllocatedStorage");
if let Some(var_1378) = &input.allocated_storage {
scope_1377.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1378).into()),
);
}
#[allow(unused_mut)]
let mut scope_1379 = writer.prefix("DBInstanceClass");
if let Some(var_1380) = &input.db_instance_class {
scope_1379.string(var_1380);
}
#[allow(unused_mut)]
let mut scope_1381 = writer.prefix("DBSubnetGroupName");
if let Some(var_1382) = &input.db_subnet_group_name {
scope_1381.string(var_1382);
}
#[allow(unused_mut)]
let mut scope_1383 = writer.prefix("DBSecurityGroups");
if let Some(var_1384) = &input.db_security_groups {
let mut list_1386 = scope_1383.start_list(false, Some("DBSecurityGroupName"));
for item_1385 in var_1384 {
#[allow(unused_mut)]
let mut entry_1387 = list_1386.entry();
entry_1387.string(item_1385);
}
list_1386.finish();
}
#[allow(unused_mut)]
let mut scope_1388 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_1389) = &input.vpc_security_group_ids {
let mut list_1391 = scope_1388.start_list(false, Some("VpcSecurityGroupId"));
for item_1390 in var_1389 {
#[allow(unused_mut)]
let mut entry_1392 = list_1391.entry();
entry_1392.string(item_1390);
}
list_1391.finish();
}
#[allow(unused_mut)]
let mut scope_1393 = writer.prefix("ApplyImmediately");
if input.apply_immediately {
scope_1393.boolean(input.apply_immediately);
}
#[allow(unused_mut)]
let mut scope_1394 = writer.prefix("MasterUserPassword");
if let Some(var_1395) = &input.master_user_password {
scope_1394.string(var_1395);
}
#[allow(unused_mut)]
let mut scope_1396 = writer.prefix("DBParameterGroupName");
if let Some(var_1397) = &input.db_parameter_group_name {
scope_1396.string(var_1397);
}
#[allow(unused_mut)]
let mut scope_1398 = writer.prefix("BackupRetentionPeriod");
if let Some(var_1399) = &input.backup_retention_period {
scope_1398.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1399).into()),
);
}
#[allow(unused_mut)]
let mut scope_1400 = writer.prefix("PreferredBackupWindow");
if let Some(var_1401) = &input.preferred_backup_window {
scope_1400.string(var_1401);
}
#[allow(unused_mut)]
let mut scope_1402 = writer.prefix("PreferredMaintenanceWindow");
if let Some(var_1403) = &input.preferred_maintenance_window {
scope_1402.string(var_1403);
}
#[allow(unused_mut)]
let mut scope_1404 = writer.prefix("MultiAZ");
if let Some(var_1405) = &input.multi_az {
scope_1404.boolean(*var_1405);
}
#[allow(unused_mut)]
let mut scope_1406 = writer.prefix("EngineVersion");
if let Some(var_1407) = &input.engine_version {
scope_1406.string(var_1407);
}
#[allow(unused_mut)]
let mut scope_1408 = writer.prefix("AllowMajorVersionUpgrade");
if input.allow_major_version_upgrade {
scope_1408.boolean(input.allow_major_version_upgrade);
}
#[allow(unused_mut)]
let mut scope_1409 = writer.prefix("AutoMinorVersionUpgrade");
if let Some(var_1410) = &input.auto_minor_version_upgrade {
scope_1409.boolean(*var_1410);
}
#[allow(unused_mut)]
let mut scope_1411 = writer.prefix("LicenseModel");
if let Some(var_1412) = &input.license_model {
scope_1411.string(var_1412);
}
#[allow(unused_mut)]
let mut scope_1413 = writer.prefix("Iops");
if let Some(var_1414) = &input.iops {
scope_1413.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1414).into()),
);
}
#[allow(unused_mut)]
let mut scope_1415 = writer.prefix("OptionGroupName");
if let Some(var_1416) = &input.option_group_name {
scope_1415.string(var_1416);
}
#[allow(unused_mut)]
let mut scope_1417 = writer.prefix("NewDBInstanceIdentifier");
if let Some(var_1418) = &input.new_db_instance_identifier {
scope_1417.string(var_1418);
}
#[allow(unused_mut)]
let mut scope_1419 = writer.prefix("StorageType");
if let Some(var_1420) = &input.storage_type {
scope_1419.string(var_1420);
}
#[allow(unused_mut)]
let mut scope_1421 = writer.prefix("TdeCredentialArn");
if let Some(var_1422) = &input.tde_credential_arn {
scope_1421.string(var_1422);
}
#[allow(unused_mut)]
let mut scope_1423 = writer.prefix("TdeCredentialPassword");
if let Some(var_1424) = &input.tde_credential_password {
scope_1423.string(var_1424);
}
#[allow(unused_mut)]
let mut scope_1425 = writer.prefix("CACertificateIdentifier");
if let Some(var_1426) = &input.ca_certificate_identifier {
scope_1425.string(var_1426);
}
#[allow(unused_mut)]
let mut scope_1427 = writer.prefix("Domain");
if let Some(var_1428) = &input.domain {
scope_1427.string(var_1428);
}
#[allow(unused_mut)]
let mut scope_1429 = writer.prefix("CopyTagsToSnapshot");
if let Some(var_1430) = &input.copy_tags_to_snapshot {
scope_1429.boolean(*var_1430);
}
#[allow(unused_mut)]
let mut scope_1431 = writer.prefix("MonitoringInterval");
if let Some(var_1432) = &input.monitoring_interval {
scope_1431.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1432).into()),
);
}
#[allow(unused_mut)]
let mut scope_1433 = writer.prefix("DBPortNumber");
if let Some(var_1434) = &input.db_port_number {
scope_1433.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1434).into()),
);
}
#[allow(unused_mut)]
let mut scope_1435 = writer.prefix("PubliclyAccessible");
if let Some(var_1436) = &input.publicly_accessible {
scope_1435.boolean(*var_1436);
}
#[allow(unused_mut)]
let mut scope_1437 = writer.prefix("MonitoringRoleArn");
if let Some(var_1438) = &input.monitoring_role_arn {
scope_1437.string(var_1438);
}
#[allow(unused_mut)]
let mut scope_1439 = writer.prefix("DomainIAMRoleName");
if let Some(var_1440) = &input.domain_iam_role_name {
scope_1439.string(var_1440);
}
#[allow(unused_mut)]
let mut scope_1441 = writer.prefix("PromotionTier");
if let Some(var_1442) = &input.promotion_tier {
scope_1441.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1442).into()),
);
}
#[allow(unused_mut)]
let mut scope_1443 = writer.prefix("EnableIAMDatabaseAuthentication");
if let Some(var_1444) = &input.enable_iam_database_authentication {
scope_1443.boolean(*var_1444);
}
#[allow(unused_mut)]
let mut scope_1445 = writer.prefix("EnablePerformanceInsights");
if let Some(var_1446) = &input.enable_performance_insights {
scope_1445.boolean(*var_1446);
}
#[allow(unused_mut)]
let mut scope_1447 = writer.prefix("PerformanceInsightsKMSKeyId");
if let Some(var_1448) = &input.performance_insights_kms_key_id {
scope_1447.string(var_1448);
}
#[allow(unused_mut)]
let mut scope_1449 = writer.prefix("PerformanceInsightsRetentionPeriod");
if let Some(var_1450) = &input.performance_insights_retention_period {
scope_1449.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1450).into()),
);
}
#[allow(unused_mut)]
let mut scope_1451 = writer.prefix("CloudwatchLogsExportConfiguration");
if let Some(var_1452) = &input.cloudwatch_logs_export_configuration {
crate::query_ser::serialize_structure_crate_model_cloudwatch_logs_export_configuration(
scope_1451, var_1452,
)?;
}
#[allow(unused_mut)]
let mut scope_1453 = writer.prefix("ProcessorFeatures");
if let Some(var_1454) = &input.processor_features {
let mut list_1456 = scope_1453.start_list(false, Some("ProcessorFeature"));
for item_1455 in var_1454 {
#[allow(unused_mut)]
let mut entry_1457 = list_1456.entry();
crate::query_ser::serialize_structure_crate_model_processor_feature(
entry_1457, item_1455,
)?;
}
list_1456.finish();
}
#[allow(unused_mut)]
let mut scope_1458 = writer.prefix("UseDefaultProcessorFeatures");
if let Some(var_1459) = &input.use_default_processor_features {
scope_1458.boolean(*var_1459);
}
#[allow(unused_mut)]
let mut scope_1460 = writer.prefix("DeletionProtection");
if let Some(var_1461) = &input.deletion_protection {
scope_1460.boolean(*var_1461);
}
#[allow(unused_mut)]
let mut scope_1462 = writer.prefix("MaxAllocatedStorage");
if let Some(var_1463) = &input.max_allocated_storage {
scope_1462.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1463).into()),
);
}
#[allow(unused_mut)]
let mut scope_1464 = writer.prefix("CertificateRotationRestart");
if let Some(var_1465) = &input.certificate_rotation_restart {
scope_1464.boolean(*var_1465);
}
#[allow(unused_mut)]
let mut scope_1466 = writer.prefix("ReplicaMode");
if let Some(var_1467) = &input.replica_mode {
scope_1466.string(var_1467.as_str());
}
#[allow(unused_mut)]
let mut scope_1468 = writer.prefix("EnableCustomerOwnedIp");
if let Some(var_1469) = &input.enable_customer_owned_ip {
scope_1468.boolean(*var_1469);
}
#[allow(unused_mut)]
let mut scope_1470 = writer.prefix("AwsBackupRecoveryPointArn");
if let Some(var_1471) = &input.aws_backup_recovery_point_arn {
scope_1470.string(var_1471);
}
#[allow(unused_mut)]
let mut scope_1472 = writer.prefix("AutomationMode");
if let Some(var_1473) = &input.automation_mode {
scope_1472.string(var_1473.as_str());
}
#[allow(unused_mut)]
let mut scope_1474 = writer.prefix("ResumeFullAutomationModeMinutes");
if let Some(var_1475) = &input.resume_full_automation_mode_minutes {
scope_1474.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1475).into()),
);
}
#[allow(unused_mut)]
let mut scope_1476 = writer.prefix("NetworkType");
if let Some(var_1477) = &input.network_type {
scope_1476.string(var_1477);
}
#[allow(unused_mut)]
let mut scope_1478 = writer.prefix("StorageThroughput");
if let Some(var_1479) = &input.storage_throughput {
scope_1478.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1479).into()),
);
}
#[allow(unused_mut)]
let mut scope_1480 = writer.prefix("ManageMasterUserPassword");
if let Some(var_1481) = &input.manage_master_user_password {
scope_1480.boolean(*var_1481);
}
#[allow(unused_mut)]
let mut scope_1482 = writer.prefix("RotateMasterUserPassword");
if let Some(var_1483) = &input.rotate_master_user_password {
scope_1482.boolean(*var_1483);
}
#[allow(unused_mut)]
let mut scope_1484 = writer.prefix("MasterUserSecretKmsKeyId");
if let Some(var_1485) = &input.master_user_secret_kms_key_id {
scope_1484.string(var_1485);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_db_parameter_group(
input: &crate::input::ModifyDbParameterGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyDBParameterGroup", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1486 = writer.prefix("DBParameterGroupName");
if let Some(var_1487) = &input.db_parameter_group_name {
scope_1486.string(var_1487);
}
#[allow(unused_mut)]
let mut scope_1488 = writer.prefix("Parameters");
if let Some(var_1489) = &input.parameters {
let mut list_1491 = scope_1488.start_list(false, Some("Parameter"));
for item_1490 in var_1489 {
#[allow(unused_mut)]
let mut entry_1492 = list_1491.entry();
crate::query_ser::serialize_structure_crate_model_parameter(entry_1492, item_1490)?;
}
list_1491.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_db_proxy(
input: &crate::input::ModifyDbProxyInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ModifyDBProxy", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1493 = writer.prefix("DBProxyName");
if let Some(var_1494) = &input.db_proxy_name {
scope_1493.string(var_1494);
}
#[allow(unused_mut)]
let mut scope_1495 = writer.prefix("NewDBProxyName");
if let Some(var_1496) = &input.new_db_proxy_name {
scope_1495.string(var_1496);
}
#[allow(unused_mut)]
let mut scope_1497 = writer.prefix("Auth");
if let Some(var_1498) = &input.auth {
let mut list_1500 = scope_1497.start_list(false, None);
for item_1499 in var_1498 {
#[allow(unused_mut)]
let mut entry_1501 = list_1500.entry();
crate::query_ser::serialize_structure_crate_model_user_auth_config(
entry_1501, item_1499,
)?;
}
list_1500.finish();
}
#[allow(unused_mut)]
let mut scope_1502 = writer.prefix("RequireTLS");
if let Some(var_1503) = &input.require_tls {
scope_1502.boolean(*var_1503);
}
#[allow(unused_mut)]
let mut scope_1504 = writer.prefix("IdleClientTimeout");
if let Some(var_1505) = &input.idle_client_timeout {
scope_1504.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1505).into()),
);
}
#[allow(unused_mut)]
let mut scope_1506 = writer.prefix("DebugLogging");
if let Some(var_1507) = &input.debug_logging {
scope_1506.boolean(*var_1507);
}
#[allow(unused_mut)]
let mut scope_1508 = writer.prefix("RoleArn");
if let Some(var_1509) = &input.role_arn {
scope_1508.string(var_1509);
}
#[allow(unused_mut)]
let mut scope_1510 = writer.prefix("SecurityGroups");
if let Some(var_1511) = &input.security_groups {
let mut list_1513 = scope_1510.start_list(false, None);
for item_1512 in var_1511 {
#[allow(unused_mut)]
let mut entry_1514 = list_1513.entry();
entry_1514.string(item_1512);
}
list_1513.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_db_proxy_endpoint(
input: &crate::input::ModifyDbProxyEndpointInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyDBProxyEndpoint", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1515 = writer.prefix("DBProxyEndpointName");
if let Some(var_1516) = &input.db_proxy_endpoint_name {
scope_1515.string(var_1516);
}
#[allow(unused_mut)]
let mut scope_1517 = writer.prefix("NewDBProxyEndpointName");
if let Some(var_1518) = &input.new_db_proxy_endpoint_name {
scope_1517.string(var_1518);
}
#[allow(unused_mut)]
let mut scope_1519 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_1520) = &input.vpc_security_group_ids {
let mut list_1522 = scope_1519.start_list(false, None);
for item_1521 in var_1520 {
#[allow(unused_mut)]
let mut entry_1523 = list_1522.entry();
entry_1523.string(item_1521);
}
list_1522.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_db_proxy_target_group(
input: &crate::input::ModifyDbProxyTargetGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyDBProxyTargetGroup", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1524 = writer.prefix("TargetGroupName");
if let Some(var_1525) = &input.target_group_name {
scope_1524.string(var_1525);
}
#[allow(unused_mut)]
let mut scope_1526 = writer.prefix("DBProxyName");
if let Some(var_1527) = &input.db_proxy_name {
scope_1526.string(var_1527);
}
#[allow(unused_mut)]
let mut scope_1528 = writer.prefix("ConnectionPoolConfig");
if let Some(var_1529) = &input.connection_pool_config {
crate::query_ser::serialize_structure_crate_model_connection_pool_configuration(
scope_1528, var_1529,
)?;
}
#[allow(unused_mut)]
let mut scope_1530 = writer.prefix("NewName");
if let Some(var_1531) = &input.new_name {
scope_1530.string(var_1531);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_db_snapshot(
input: &crate::input::ModifyDbSnapshotInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ModifyDBSnapshot", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1532 = writer.prefix("DBSnapshotIdentifier");
if let Some(var_1533) = &input.db_snapshot_identifier {
scope_1532.string(var_1533);
}
#[allow(unused_mut)]
let mut scope_1534 = writer.prefix("EngineVersion");
if let Some(var_1535) = &input.engine_version {
scope_1534.string(var_1535);
}
#[allow(unused_mut)]
let mut scope_1536 = writer.prefix("OptionGroupName");
if let Some(var_1537) = &input.option_group_name {
scope_1536.string(var_1537);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_db_snapshot_attribute(
input: &crate::input::ModifyDbSnapshotAttributeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyDBSnapshotAttribute", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1538 = writer.prefix("DBSnapshotIdentifier");
if let Some(var_1539) = &input.db_snapshot_identifier {
scope_1538.string(var_1539);
}
#[allow(unused_mut)]
let mut scope_1540 = writer.prefix("AttributeName");
if let Some(var_1541) = &input.attribute_name {
scope_1540.string(var_1541);
}
#[allow(unused_mut)]
let mut scope_1542 = writer.prefix("ValuesToAdd");
if let Some(var_1543) = &input.values_to_add {
let mut list_1545 = scope_1542.start_list(false, Some("AttributeValue"));
for item_1544 in var_1543 {
#[allow(unused_mut)]
let mut entry_1546 = list_1545.entry();
entry_1546.string(item_1544);
}
list_1545.finish();
}
#[allow(unused_mut)]
let mut scope_1547 = writer.prefix("ValuesToRemove");
if let Some(var_1548) = &input.values_to_remove {
let mut list_1550 = scope_1547.start_list(false, Some("AttributeValue"));
for item_1549 in var_1548 {
#[allow(unused_mut)]
let mut entry_1551 = list_1550.entry();
entry_1551.string(item_1549);
}
list_1550.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_db_subnet_group(
input: &crate::input::ModifyDbSubnetGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyDBSubnetGroup", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1552 = writer.prefix("DBSubnetGroupName");
if let Some(var_1553) = &input.db_subnet_group_name {
scope_1552.string(var_1553);
}
#[allow(unused_mut)]
let mut scope_1554 = writer.prefix("DBSubnetGroupDescription");
if let Some(var_1555) = &input.db_subnet_group_description {
scope_1554.string(var_1555);
}
#[allow(unused_mut)]
let mut scope_1556 = writer.prefix("SubnetIds");
if let Some(var_1557) = &input.subnet_ids {
let mut list_1559 = scope_1556.start_list(false, Some("SubnetIdentifier"));
for item_1558 in var_1557 {
#[allow(unused_mut)]
let mut entry_1560 = list_1559.entry();
entry_1560.string(item_1558);
}
list_1559.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_event_subscription(
input: &crate::input::ModifyEventSubscriptionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyEventSubscription", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1561 = writer.prefix("SubscriptionName");
if let Some(var_1562) = &input.subscription_name {
scope_1561.string(var_1562);
}
#[allow(unused_mut)]
let mut scope_1563 = writer.prefix("SnsTopicArn");
if let Some(var_1564) = &input.sns_topic_arn {
scope_1563.string(var_1564);
}
#[allow(unused_mut)]
let mut scope_1565 = writer.prefix("SourceType");
if let Some(var_1566) = &input.source_type {
scope_1565.string(var_1566);
}
#[allow(unused_mut)]
let mut scope_1567 = writer.prefix("EventCategories");
if let Some(var_1568) = &input.event_categories {
let mut list_1570 = scope_1567.start_list(false, Some("EventCategory"));
for item_1569 in var_1568 {
#[allow(unused_mut)]
let mut entry_1571 = list_1570.entry();
entry_1571.string(item_1569);
}
list_1570.finish();
}
#[allow(unused_mut)]
let mut scope_1572 = writer.prefix("Enabled");
if let Some(var_1573) = &input.enabled {
scope_1572.boolean(*var_1573);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_global_cluster(
input: &crate::input::ModifyGlobalClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyGlobalCluster", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1574 = writer.prefix("GlobalClusterIdentifier");
if let Some(var_1575) = &input.global_cluster_identifier {
scope_1574.string(var_1575);
}
#[allow(unused_mut)]
let mut scope_1576 = writer.prefix("NewGlobalClusterIdentifier");
if let Some(var_1577) = &input.new_global_cluster_identifier {
scope_1576.string(var_1577);
}
#[allow(unused_mut)]
let mut scope_1578 = writer.prefix("DeletionProtection");
if let Some(var_1579) = &input.deletion_protection {
scope_1578.boolean(*var_1579);
}
#[allow(unused_mut)]
let mut scope_1580 = writer.prefix("EngineVersion");
if let Some(var_1581) = &input.engine_version {
scope_1580.string(var_1581);
}
#[allow(unused_mut)]
let mut scope_1582 = writer.prefix("AllowMajorVersionUpgrade");
if let Some(var_1583) = &input.allow_major_version_upgrade {
scope_1582.boolean(*var_1583);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_option_group(
input: &crate::input::ModifyOptionGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyOptionGroup", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1584 = writer.prefix("OptionGroupName");
if let Some(var_1585) = &input.option_group_name {
scope_1584.string(var_1585);
}
#[allow(unused_mut)]
let mut scope_1586 = writer.prefix("OptionsToInclude");
if let Some(var_1587) = &input.options_to_include {
let mut list_1589 = scope_1586.start_list(false, Some("OptionConfiguration"));
for item_1588 in var_1587 {
#[allow(unused_mut)]
let mut entry_1590 = list_1589.entry();
crate::query_ser::serialize_structure_crate_model_option_configuration(
entry_1590, item_1588,
)?;
}
list_1589.finish();
}
#[allow(unused_mut)]
let mut scope_1591 = writer.prefix("OptionsToRemove");
if let Some(var_1592) = &input.options_to_remove {
let mut list_1594 = scope_1591.start_list(false, None);
for item_1593 in var_1592 {
#[allow(unused_mut)]
let mut entry_1595 = list_1594.entry();
entry_1595.string(item_1593);
}
list_1594.finish();
}
#[allow(unused_mut)]
let mut scope_1596 = writer.prefix("ApplyImmediately");
if input.apply_immediately {
scope_1596.boolean(input.apply_immediately);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_promote_read_replica(
input: &crate::input::PromoteReadReplicaInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "PromoteReadReplica", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1597 = writer.prefix("DBInstanceIdentifier");
if let Some(var_1598) = &input.db_instance_identifier {
scope_1597.string(var_1598);
}
#[allow(unused_mut)]
let mut scope_1599 = writer.prefix("BackupRetentionPeriod");
if let Some(var_1600) = &input.backup_retention_period {
scope_1599.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1600).into()),
);
}
#[allow(unused_mut)]
let mut scope_1601 = writer.prefix("PreferredBackupWindow");
if let Some(var_1602) = &input.preferred_backup_window {
scope_1601.string(var_1602);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_promote_read_replica_db_cluster(
input: &crate::input::PromoteReadReplicaDbClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "PromoteReadReplicaDBCluster", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1603 = writer.prefix("DBClusterIdentifier");
if let Some(var_1604) = &input.db_cluster_identifier {
scope_1603.string(var_1604);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_purchase_reserved_db_instances_offering(
input: &crate::input::PurchaseReservedDbInstancesOfferingInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"PurchaseReservedDBInstancesOffering",
"2014-10-31",
);
#[allow(unused_mut)]
let mut scope_1605 = writer.prefix("ReservedDBInstancesOfferingId");
if let Some(var_1606) = &input.reserved_db_instances_offering_id {
scope_1605.string(var_1606);
}
#[allow(unused_mut)]
let mut scope_1607 = writer.prefix("ReservedDBInstanceId");
if let Some(var_1608) = &input.reserved_db_instance_id {
scope_1607.string(var_1608);
}
#[allow(unused_mut)]
let mut scope_1609 = writer.prefix("DBInstanceCount");
if let Some(var_1610) = &input.db_instance_count {
scope_1609.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1610).into()),
);
}
#[allow(unused_mut)]
let mut scope_1611 = writer.prefix("Tags");
if let Some(var_1612) = &input.tags {
let mut list_1614 = scope_1611.start_list(false, Some("Tag"));
for item_1613 in var_1612 {
#[allow(unused_mut)]
let mut entry_1615 = list_1614.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_1615, item_1613)?;
}
list_1614.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_reboot_db_cluster(
input: &crate::input::RebootDbClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "RebootDBCluster", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1616 = writer.prefix("DBClusterIdentifier");
if let Some(var_1617) = &input.db_cluster_identifier {
scope_1616.string(var_1617);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_reboot_db_instance(
input: &crate::input::RebootDbInstanceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "RebootDBInstance", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1618 = writer.prefix("DBInstanceIdentifier");
if let Some(var_1619) = &input.db_instance_identifier {
scope_1618.string(var_1619);
}
#[allow(unused_mut)]
let mut scope_1620 = writer.prefix("ForceFailover");
if let Some(var_1621) = &input.force_failover {
scope_1620.boolean(*var_1621);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_register_db_proxy_targets(
input: &crate::input::RegisterDbProxyTargetsInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RegisterDBProxyTargets", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1622 = writer.prefix("DBProxyName");
if let Some(var_1623) = &input.db_proxy_name {
scope_1622.string(var_1623);
}
#[allow(unused_mut)]
let mut scope_1624 = writer.prefix("TargetGroupName");
if let Some(var_1625) = &input.target_group_name {
scope_1624.string(var_1625);
}
#[allow(unused_mut)]
let mut scope_1626 = writer.prefix("DBInstanceIdentifiers");
if let Some(var_1627) = &input.db_instance_identifiers {
let mut list_1629 = scope_1626.start_list(false, None);
for item_1628 in var_1627 {
#[allow(unused_mut)]
let mut entry_1630 = list_1629.entry();
entry_1630.string(item_1628);
}
list_1629.finish();
}
#[allow(unused_mut)]
let mut scope_1631 = writer.prefix("DBClusterIdentifiers");
if let Some(var_1632) = &input.db_cluster_identifiers {
let mut list_1634 = scope_1631.start_list(false, None);
for item_1633 in var_1632 {
#[allow(unused_mut)]
let mut entry_1635 = list_1634.entry();
entry_1635.string(item_1633);
}
list_1634.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_remove_from_global_cluster(
input: &crate::input::RemoveFromGlobalClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RemoveFromGlobalCluster", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1636 = writer.prefix("GlobalClusterIdentifier");
if let Some(var_1637) = &input.global_cluster_identifier {
scope_1636.string(var_1637);
}
#[allow(unused_mut)]
let mut scope_1638 = writer.prefix("DbClusterIdentifier");
if let Some(var_1639) = &input.db_cluster_identifier {
scope_1638.string(var_1639);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_remove_role_from_db_cluster(
input: &crate::input::RemoveRoleFromDbClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RemoveRoleFromDBCluster", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1640 = writer.prefix("DBClusterIdentifier");
if let Some(var_1641) = &input.db_cluster_identifier {
scope_1640.string(var_1641);
}
#[allow(unused_mut)]
let mut scope_1642 = writer.prefix("RoleArn");
if let Some(var_1643) = &input.role_arn {
scope_1642.string(var_1643);
}
#[allow(unused_mut)]
let mut scope_1644 = writer.prefix("FeatureName");
if let Some(var_1645) = &input.feature_name {
scope_1644.string(var_1645);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_remove_role_from_db_instance(
input: &crate::input::RemoveRoleFromDbInstanceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RemoveRoleFromDBInstance", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1646 = writer.prefix("DBInstanceIdentifier");
if let Some(var_1647) = &input.db_instance_identifier {
scope_1646.string(var_1647);
}
#[allow(unused_mut)]
let mut scope_1648 = writer.prefix("RoleArn");
if let Some(var_1649) = &input.role_arn {
scope_1648.string(var_1649);
}
#[allow(unused_mut)]
let mut scope_1650 = writer.prefix("FeatureName");
if let Some(var_1651) = &input.feature_name {
scope_1650.string(var_1651);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_remove_source_identifier_from_subscription(
input: &crate::input::RemoveSourceIdentifierFromSubscriptionInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"RemoveSourceIdentifierFromSubscription",
"2014-10-31",
);
#[allow(unused_mut)]
let mut scope_1652 = writer.prefix("SubscriptionName");
if let Some(var_1653) = &input.subscription_name {
scope_1652.string(var_1653);
}
#[allow(unused_mut)]
let mut scope_1654 = writer.prefix("SourceIdentifier");
if let Some(var_1655) = &input.source_identifier {
scope_1654.string(var_1655);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_remove_tags_from_resource(
input: &crate::input::RemoveTagsFromResourceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RemoveTagsFromResource", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1656 = writer.prefix("ResourceName");
if let Some(var_1657) = &input.resource_name {
scope_1656.string(var_1657);
}
#[allow(unused_mut)]
let mut scope_1658 = writer.prefix("TagKeys");
if let Some(var_1659) = &input.tag_keys {
let mut list_1661 = scope_1658.start_list(false, None);
for item_1660 in var_1659 {
#[allow(unused_mut)]
let mut entry_1662 = list_1661.entry();
entry_1662.string(item_1660);
}
list_1661.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_reset_db_cluster_parameter_group(
input: &crate::input::ResetDbClusterParameterGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ResetDBClusterParameterGroup", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1663 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_1664) = &input.db_cluster_parameter_group_name {
scope_1663.string(var_1664);
}
#[allow(unused_mut)]
let mut scope_1665 = writer.prefix("ResetAllParameters");
if input.reset_all_parameters {
scope_1665.boolean(input.reset_all_parameters);
}
#[allow(unused_mut)]
let mut scope_1666 = writer.prefix("Parameters");
if let Some(var_1667) = &input.parameters {
let mut list_1669 = scope_1666.start_list(false, Some("Parameter"));
for item_1668 in var_1667 {
#[allow(unused_mut)]
let mut entry_1670 = list_1669.entry();
crate::query_ser::serialize_structure_crate_model_parameter(entry_1670, item_1668)?;
}
list_1669.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_reset_db_parameter_group(
input: &crate::input::ResetDbParameterGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ResetDBParameterGroup", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1671 = writer.prefix("DBParameterGroupName");
if let Some(var_1672) = &input.db_parameter_group_name {
scope_1671.string(var_1672);
}
#[allow(unused_mut)]
let mut scope_1673 = writer.prefix("ResetAllParameters");
if input.reset_all_parameters {
scope_1673.boolean(input.reset_all_parameters);
}
#[allow(unused_mut)]
let mut scope_1674 = writer.prefix("Parameters");
if let Some(var_1675) = &input.parameters {
let mut list_1677 = scope_1674.start_list(false, Some("Parameter"));
for item_1676 in var_1675 {
#[allow(unused_mut)]
let mut entry_1678 = list_1677.entry();
crate::query_ser::serialize_structure_crate_model_parameter(entry_1678, item_1676)?;
}
list_1677.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_restore_db_cluster_from_s3(
input: &crate::input::RestoreDbClusterFromS3Input,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RestoreDBClusterFromS3", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1679 = writer.prefix("AvailabilityZones");
if let Some(var_1680) = &input.availability_zones {
let mut list_1682 = scope_1679.start_list(false, Some("AvailabilityZone"));
for item_1681 in var_1680 {
#[allow(unused_mut)]
let mut entry_1683 = list_1682.entry();
entry_1683.string(item_1681);
}
list_1682.finish();
}
#[allow(unused_mut)]
let mut scope_1684 = writer.prefix("BackupRetentionPeriod");
if let Some(var_1685) = &input.backup_retention_period {
scope_1684.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1685).into()),
);
}
#[allow(unused_mut)]
let mut scope_1686 = writer.prefix("CharacterSetName");
if let Some(var_1687) = &input.character_set_name {
scope_1686.string(var_1687);
}
#[allow(unused_mut)]
let mut scope_1688 = writer.prefix("DatabaseName");
if let Some(var_1689) = &input.database_name {
scope_1688.string(var_1689);
}
#[allow(unused_mut)]
let mut scope_1690 = writer.prefix("DBClusterIdentifier");
if let Some(var_1691) = &input.db_cluster_identifier {
scope_1690.string(var_1691);
}
#[allow(unused_mut)]
let mut scope_1692 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_1693) = &input.db_cluster_parameter_group_name {
scope_1692.string(var_1693);
}
#[allow(unused_mut)]
let mut scope_1694 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_1695) = &input.vpc_security_group_ids {
let mut list_1697 = scope_1694.start_list(false, Some("VpcSecurityGroupId"));
for item_1696 in var_1695 {
#[allow(unused_mut)]
let mut entry_1698 = list_1697.entry();
entry_1698.string(item_1696);
}
list_1697.finish();
}
#[allow(unused_mut)]
let mut scope_1699 = writer.prefix("DBSubnetGroupName");
if let Some(var_1700) = &input.db_subnet_group_name {
scope_1699.string(var_1700);
}
#[allow(unused_mut)]
let mut scope_1701 = writer.prefix("Engine");
if let Some(var_1702) = &input.engine {
scope_1701.string(var_1702);
}
#[allow(unused_mut)]
let mut scope_1703 = writer.prefix("EngineVersion");
if let Some(var_1704) = &input.engine_version {
scope_1703.string(var_1704);
}
#[allow(unused_mut)]
let mut scope_1705 = writer.prefix("Port");
if let Some(var_1706) = &input.port {
scope_1705.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1706).into()),
);
}
#[allow(unused_mut)]
let mut scope_1707 = writer.prefix("MasterUsername");
if let Some(var_1708) = &input.master_username {
scope_1707.string(var_1708);
}
#[allow(unused_mut)]
let mut scope_1709 = writer.prefix("MasterUserPassword");
if let Some(var_1710) = &input.master_user_password {
scope_1709.string(var_1710);
}
#[allow(unused_mut)]
let mut scope_1711 = writer.prefix("OptionGroupName");
if let Some(var_1712) = &input.option_group_name {
scope_1711.string(var_1712);
}
#[allow(unused_mut)]
let mut scope_1713 = writer.prefix("PreferredBackupWindow");
if let Some(var_1714) = &input.preferred_backup_window {
scope_1713.string(var_1714);
}
#[allow(unused_mut)]
let mut scope_1715 = writer.prefix("PreferredMaintenanceWindow");
if let Some(var_1716) = &input.preferred_maintenance_window {
scope_1715.string(var_1716);
}
#[allow(unused_mut)]
let mut scope_1717 = writer.prefix("Tags");
if let Some(var_1718) = &input.tags {
let mut list_1720 = scope_1717.start_list(false, Some("Tag"));
for item_1719 in var_1718 {
#[allow(unused_mut)]
let mut entry_1721 = list_1720.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_1721, item_1719)?;
}
list_1720.finish();
}
#[allow(unused_mut)]
let mut scope_1722 = writer.prefix("StorageEncrypted");
if let Some(var_1723) = &input.storage_encrypted {
scope_1722.boolean(*var_1723);
}
#[allow(unused_mut)]
let mut scope_1724 = writer.prefix("KmsKeyId");
if let Some(var_1725) = &input.kms_key_id {
scope_1724.string(var_1725);
}
#[allow(unused_mut)]
let mut scope_1726 = writer.prefix("EnableIAMDatabaseAuthentication");
if let Some(var_1727) = &input.enable_iam_database_authentication {
scope_1726.boolean(*var_1727);
}
#[allow(unused_mut)]
let mut scope_1728 = writer.prefix("SourceEngine");
if let Some(var_1729) = &input.source_engine {
scope_1728.string(var_1729);
}
#[allow(unused_mut)]
let mut scope_1730 = writer.prefix("SourceEngineVersion");
if let Some(var_1731) = &input.source_engine_version {
scope_1730.string(var_1731);
}
#[allow(unused_mut)]
let mut scope_1732 = writer.prefix("S3BucketName");
if let Some(var_1733) = &input.s3_bucket_name {
scope_1732.string(var_1733);
}
#[allow(unused_mut)]
let mut scope_1734 = writer.prefix("S3Prefix");
if let Some(var_1735) = &input.s3_prefix {
scope_1734.string(var_1735);
}
#[allow(unused_mut)]
let mut scope_1736 = writer.prefix("S3IngestionRoleArn");
if let Some(var_1737) = &input.s3_ingestion_role_arn {
scope_1736.string(var_1737);
}
#[allow(unused_mut)]
let mut scope_1738 = writer.prefix("BacktrackWindow");
if let Some(var_1739) = &input.backtrack_window {
scope_1738.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1739).into()),
);
}
#[allow(unused_mut)]
let mut scope_1740 = writer.prefix("EnableCloudwatchLogsExports");
if let Some(var_1741) = &input.enable_cloudwatch_logs_exports {
let mut list_1743 = scope_1740.start_list(false, None);
for item_1742 in var_1741 {
#[allow(unused_mut)]
let mut entry_1744 = list_1743.entry();
entry_1744.string(item_1742);
}
list_1743.finish();
}
#[allow(unused_mut)]
let mut scope_1745 = writer.prefix("DeletionProtection");
if let Some(var_1746) = &input.deletion_protection {
scope_1745.boolean(*var_1746);
}
#[allow(unused_mut)]
let mut scope_1747 = writer.prefix("CopyTagsToSnapshot");
if let Some(var_1748) = &input.copy_tags_to_snapshot {
scope_1747.boolean(*var_1748);
}
#[allow(unused_mut)]
let mut scope_1749 = writer.prefix("Domain");
if let Some(var_1750) = &input.domain {
scope_1749.string(var_1750);
}
#[allow(unused_mut)]
let mut scope_1751 = writer.prefix("DomainIAMRoleName");
if let Some(var_1752) = &input.domain_iam_role_name {
scope_1751.string(var_1752);
}
#[allow(unused_mut)]
let mut scope_1753 = writer.prefix("ServerlessV2ScalingConfiguration");
if let Some(var_1754) = &input.serverless_v2_scaling_configuration {
crate::query_ser::serialize_structure_crate_model_serverless_v2_scaling_configuration(
scope_1753, var_1754,
)?;
}
#[allow(unused_mut)]
let mut scope_1755 = writer.prefix("NetworkType");
if let Some(var_1756) = &input.network_type {
scope_1755.string(var_1756);
}
#[allow(unused_mut)]
let mut scope_1757 = writer.prefix("ManageMasterUserPassword");
if let Some(var_1758) = &input.manage_master_user_password {
scope_1757.boolean(*var_1758);
}
#[allow(unused_mut)]
let mut scope_1759 = writer.prefix("MasterUserSecretKmsKeyId");
if let Some(var_1760) = &input.master_user_secret_kms_key_id {
scope_1759.string(var_1760);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_restore_db_cluster_from_snapshot(
input: &crate::input::RestoreDbClusterFromSnapshotInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RestoreDBClusterFromSnapshot", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1761 = writer.prefix("AvailabilityZones");
if let Some(var_1762) = &input.availability_zones {
let mut list_1764 = scope_1761.start_list(false, Some("AvailabilityZone"));
for item_1763 in var_1762 {
#[allow(unused_mut)]
let mut entry_1765 = list_1764.entry();
entry_1765.string(item_1763);
}
list_1764.finish();
}
#[allow(unused_mut)]
let mut scope_1766 = writer.prefix("DBClusterIdentifier");
if let Some(var_1767) = &input.db_cluster_identifier {
scope_1766.string(var_1767);
}
#[allow(unused_mut)]
let mut scope_1768 = writer.prefix("SnapshotIdentifier");
if let Some(var_1769) = &input.snapshot_identifier {
scope_1768.string(var_1769);
}
#[allow(unused_mut)]
let mut scope_1770 = writer.prefix("Engine");
if let Some(var_1771) = &input.engine {
scope_1770.string(var_1771);
}
#[allow(unused_mut)]
let mut scope_1772 = writer.prefix("EngineVersion");
if let Some(var_1773) = &input.engine_version {
scope_1772.string(var_1773);
}
#[allow(unused_mut)]
let mut scope_1774 = writer.prefix("Port");
if let Some(var_1775) = &input.port {
scope_1774.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1775).into()),
);
}
#[allow(unused_mut)]
let mut scope_1776 = writer.prefix("DBSubnetGroupName");
if let Some(var_1777) = &input.db_subnet_group_name {
scope_1776.string(var_1777);
}
#[allow(unused_mut)]
let mut scope_1778 = writer.prefix("DatabaseName");
if let Some(var_1779) = &input.database_name {
scope_1778.string(var_1779);
}
#[allow(unused_mut)]
let mut scope_1780 = writer.prefix("OptionGroupName");
if let Some(var_1781) = &input.option_group_name {
scope_1780.string(var_1781);
}
#[allow(unused_mut)]
let mut scope_1782 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_1783) = &input.vpc_security_group_ids {
let mut list_1785 = scope_1782.start_list(false, Some("VpcSecurityGroupId"));
for item_1784 in var_1783 {
#[allow(unused_mut)]
let mut entry_1786 = list_1785.entry();
entry_1786.string(item_1784);
}
list_1785.finish();
}
#[allow(unused_mut)]
let mut scope_1787 = writer.prefix("Tags");
if let Some(var_1788) = &input.tags {
let mut list_1790 = scope_1787.start_list(false, Some("Tag"));
for item_1789 in var_1788 {
#[allow(unused_mut)]
let mut entry_1791 = list_1790.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_1791, item_1789)?;
}
list_1790.finish();
}
#[allow(unused_mut)]
let mut scope_1792 = writer.prefix("KmsKeyId");
if let Some(var_1793) = &input.kms_key_id {
scope_1792.string(var_1793);
}
#[allow(unused_mut)]
let mut scope_1794 = writer.prefix("EnableIAMDatabaseAuthentication");
if let Some(var_1795) = &input.enable_iam_database_authentication {
scope_1794.boolean(*var_1795);
}
#[allow(unused_mut)]
let mut scope_1796 = writer.prefix("BacktrackWindow");
if let Some(var_1797) = &input.backtrack_window {
scope_1796.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1797).into()),
);
}
#[allow(unused_mut)]
let mut scope_1798 = writer.prefix("EnableCloudwatchLogsExports");
if let Some(var_1799) = &input.enable_cloudwatch_logs_exports {
let mut list_1801 = scope_1798.start_list(false, None);
for item_1800 in var_1799 {
#[allow(unused_mut)]
let mut entry_1802 = list_1801.entry();
entry_1802.string(item_1800);
}
list_1801.finish();
}
#[allow(unused_mut)]
let mut scope_1803 = writer.prefix("EngineMode");
if let Some(var_1804) = &input.engine_mode {
scope_1803.string(var_1804);
}
#[allow(unused_mut)]
let mut scope_1805 = writer.prefix("ScalingConfiguration");
if let Some(var_1806) = &input.scaling_configuration {
crate::query_ser::serialize_structure_crate_model_scaling_configuration(
scope_1805, var_1806,
)?;
}
#[allow(unused_mut)]
let mut scope_1807 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_1808) = &input.db_cluster_parameter_group_name {
scope_1807.string(var_1808);
}
#[allow(unused_mut)]
let mut scope_1809 = writer.prefix("DeletionProtection");
if let Some(var_1810) = &input.deletion_protection {
scope_1809.boolean(*var_1810);
}
#[allow(unused_mut)]
let mut scope_1811 = writer.prefix("CopyTagsToSnapshot");
if let Some(var_1812) = &input.copy_tags_to_snapshot {
scope_1811.boolean(*var_1812);
}
#[allow(unused_mut)]
let mut scope_1813 = writer.prefix("Domain");
if let Some(var_1814) = &input.domain {
scope_1813.string(var_1814);
}
#[allow(unused_mut)]
let mut scope_1815 = writer.prefix("DomainIAMRoleName");
if let Some(var_1816) = &input.domain_iam_role_name {
scope_1815.string(var_1816);
}
#[allow(unused_mut)]
let mut scope_1817 = writer.prefix("DBClusterInstanceClass");
if let Some(var_1818) = &input.db_cluster_instance_class {
scope_1817.string(var_1818);
}
#[allow(unused_mut)]
let mut scope_1819 = writer.prefix("StorageType");
if let Some(var_1820) = &input.storage_type {
scope_1819.string(var_1820);
}
#[allow(unused_mut)]
let mut scope_1821 = writer.prefix("Iops");
if let Some(var_1822) = &input.iops {
scope_1821.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1822).into()),
);
}
#[allow(unused_mut)]
let mut scope_1823 = writer.prefix("PubliclyAccessible");
if let Some(var_1824) = &input.publicly_accessible {
scope_1823.boolean(*var_1824);
}
#[allow(unused_mut)]
let mut scope_1825 = writer.prefix("ServerlessV2ScalingConfiguration");
if let Some(var_1826) = &input.serverless_v2_scaling_configuration {
crate::query_ser::serialize_structure_crate_model_serverless_v2_scaling_configuration(
scope_1825, var_1826,
)?;
}
#[allow(unused_mut)]
let mut scope_1827 = writer.prefix("NetworkType");
if let Some(var_1828) = &input.network_type {
scope_1827.string(var_1828);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_restore_db_cluster_to_point_in_time(
input: &crate::input::RestoreDbClusterToPointInTimeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RestoreDBClusterToPointInTime", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1829 = writer.prefix("DBClusterIdentifier");
if let Some(var_1830) = &input.db_cluster_identifier {
scope_1829.string(var_1830);
}
#[allow(unused_mut)]
let mut scope_1831 = writer.prefix("RestoreType");
if let Some(var_1832) = &input.restore_type {
scope_1831.string(var_1832);
}
#[allow(unused_mut)]
let mut scope_1833 = writer.prefix("SourceDBClusterIdentifier");
if let Some(var_1834) = &input.source_db_cluster_identifier {
scope_1833.string(var_1834);
}
#[allow(unused_mut)]
let mut scope_1835 = writer.prefix("RestoreToTime");
if let Some(var_1836) = &input.restore_to_time {
scope_1835.date_time(var_1836, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_1837 = writer.prefix("UseLatestRestorableTime");
if input.use_latest_restorable_time {
scope_1837.boolean(input.use_latest_restorable_time);
}
#[allow(unused_mut)]
let mut scope_1838 = writer.prefix("Port");
if let Some(var_1839) = &input.port {
scope_1838.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1839).into()),
);
}
#[allow(unused_mut)]
let mut scope_1840 = writer.prefix("DBSubnetGroupName");
if let Some(var_1841) = &input.db_subnet_group_name {
scope_1840.string(var_1841);
}
#[allow(unused_mut)]
let mut scope_1842 = writer.prefix("OptionGroupName");
if let Some(var_1843) = &input.option_group_name {
scope_1842.string(var_1843);
}
#[allow(unused_mut)]
let mut scope_1844 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_1845) = &input.vpc_security_group_ids {
let mut list_1847 = scope_1844.start_list(false, Some("VpcSecurityGroupId"));
for item_1846 in var_1845 {
#[allow(unused_mut)]
let mut entry_1848 = list_1847.entry();
entry_1848.string(item_1846);
}
list_1847.finish();
}
#[allow(unused_mut)]
let mut scope_1849 = writer.prefix("Tags");
if let Some(var_1850) = &input.tags {
let mut list_1852 = scope_1849.start_list(false, Some("Tag"));
for item_1851 in var_1850 {
#[allow(unused_mut)]
let mut entry_1853 = list_1852.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_1853, item_1851)?;
}
list_1852.finish();
}
#[allow(unused_mut)]
let mut scope_1854 = writer.prefix("KmsKeyId");
if let Some(var_1855) = &input.kms_key_id {
scope_1854.string(var_1855);
}
#[allow(unused_mut)]
let mut scope_1856 = writer.prefix("EnableIAMDatabaseAuthentication");
if let Some(var_1857) = &input.enable_iam_database_authentication {
scope_1856.boolean(*var_1857);
}
#[allow(unused_mut)]
let mut scope_1858 = writer.prefix("BacktrackWindow");
if let Some(var_1859) = &input.backtrack_window {
scope_1858.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1859).into()),
);
}
#[allow(unused_mut)]
let mut scope_1860 = writer.prefix("EnableCloudwatchLogsExports");
if let Some(var_1861) = &input.enable_cloudwatch_logs_exports {
let mut list_1863 = scope_1860.start_list(false, None);
for item_1862 in var_1861 {
#[allow(unused_mut)]
let mut entry_1864 = list_1863.entry();
entry_1864.string(item_1862);
}
list_1863.finish();
}
#[allow(unused_mut)]
let mut scope_1865 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_1866) = &input.db_cluster_parameter_group_name {
scope_1865.string(var_1866);
}
#[allow(unused_mut)]
let mut scope_1867 = writer.prefix("DeletionProtection");
if let Some(var_1868) = &input.deletion_protection {
scope_1867.boolean(*var_1868);
}
#[allow(unused_mut)]
let mut scope_1869 = writer.prefix("CopyTagsToSnapshot");
if let Some(var_1870) = &input.copy_tags_to_snapshot {
scope_1869.boolean(*var_1870);
}
#[allow(unused_mut)]
let mut scope_1871 = writer.prefix("Domain");
if let Some(var_1872) = &input.domain {
scope_1871.string(var_1872);
}
#[allow(unused_mut)]
let mut scope_1873 = writer.prefix("DomainIAMRoleName");
if let Some(var_1874) = &input.domain_iam_role_name {
scope_1873.string(var_1874);
}
#[allow(unused_mut)]
let mut scope_1875 = writer.prefix("ScalingConfiguration");
if let Some(var_1876) = &input.scaling_configuration {
crate::query_ser::serialize_structure_crate_model_scaling_configuration(
scope_1875, var_1876,
)?;
}
#[allow(unused_mut)]
let mut scope_1877 = writer.prefix("EngineMode");
if let Some(var_1878) = &input.engine_mode {
scope_1877.string(var_1878);
}
#[allow(unused_mut)]
let mut scope_1879 = writer.prefix("DBClusterInstanceClass");
if let Some(var_1880) = &input.db_cluster_instance_class {
scope_1879.string(var_1880);
}
#[allow(unused_mut)]
let mut scope_1881 = writer.prefix("StorageType");
if let Some(var_1882) = &input.storage_type {
scope_1881.string(var_1882);
}
#[allow(unused_mut)]
let mut scope_1883 = writer.prefix("PubliclyAccessible");
if let Some(var_1884) = &input.publicly_accessible {
scope_1883.boolean(*var_1884);
}
#[allow(unused_mut)]
let mut scope_1885 = writer.prefix("Iops");
if let Some(var_1886) = &input.iops {
scope_1885.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1886).into()),
);
}
#[allow(unused_mut)]
let mut scope_1887 = writer.prefix("ServerlessV2ScalingConfiguration");
if let Some(var_1888) = &input.serverless_v2_scaling_configuration {
crate::query_ser::serialize_structure_crate_model_serverless_v2_scaling_configuration(
scope_1887, var_1888,
)?;
}
#[allow(unused_mut)]
let mut scope_1889 = writer.prefix("NetworkType");
if let Some(var_1890) = &input.network_type {
scope_1889.string(var_1890);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_restore_db_instance_from_db_snapshot(
input: &crate::input::RestoreDbInstanceFromDbSnapshotInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"RestoreDBInstanceFromDBSnapshot",
"2014-10-31",
);
#[allow(unused_mut)]
let mut scope_1891 = writer.prefix("DBInstanceIdentifier");
if let Some(var_1892) = &input.db_instance_identifier {
scope_1891.string(var_1892);
}
#[allow(unused_mut)]
let mut scope_1893 = writer.prefix("DBSnapshotIdentifier");
if let Some(var_1894) = &input.db_snapshot_identifier {
scope_1893.string(var_1894);
}
#[allow(unused_mut)]
let mut scope_1895 = writer.prefix("DBInstanceClass");
if let Some(var_1896) = &input.db_instance_class {
scope_1895.string(var_1896);
}
#[allow(unused_mut)]
let mut scope_1897 = writer.prefix("Port");
if let Some(var_1898) = &input.port {
scope_1897.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1898).into()),
);
}
#[allow(unused_mut)]
let mut scope_1899 = writer.prefix("AvailabilityZone");
if let Some(var_1900) = &input.availability_zone {
scope_1899.string(var_1900);
}
#[allow(unused_mut)]
let mut scope_1901 = writer.prefix("DBSubnetGroupName");
if let Some(var_1902) = &input.db_subnet_group_name {
scope_1901.string(var_1902);
}
#[allow(unused_mut)]
let mut scope_1903 = writer.prefix("MultiAZ");
if let Some(var_1904) = &input.multi_az {
scope_1903.boolean(*var_1904);
}
#[allow(unused_mut)]
let mut scope_1905 = writer.prefix("PubliclyAccessible");
if let Some(var_1906) = &input.publicly_accessible {
scope_1905.boolean(*var_1906);
}
#[allow(unused_mut)]
let mut scope_1907 = writer.prefix("AutoMinorVersionUpgrade");
if let Some(var_1908) = &input.auto_minor_version_upgrade {
scope_1907.boolean(*var_1908);
}
#[allow(unused_mut)]
let mut scope_1909 = writer.prefix("LicenseModel");
if let Some(var_1910) = &input.license_model {
scope_1909.string(var_1910);
}
#[allow(unused_mut)]
let mut scope_1911 = writer.prefix("DBName");
if let Some(var_1912) = &input.db_name {
scope_1911.string(var_1912);
}
#[allow(unused_mut)]
let mut scope_1913 = writer.prefix("Engine");
if let Some(var_1914) = &input.engine {
scope_1913.string(var_1914);
}
#[allow(unused_mut)]
let mut scope_1915 = writer.prefix("Iops");
if let Some(var_1916) = &input.iops {
scope_1915.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1916).into()),
);
}
#[allow(unused_mut)]
let mut scope_1917 = writer.prefix("OptionGroupName");
if let Some(var_1918) = &input.option_group_name {
scope_1917.string(var_1918);
}
#[allow(unused_mut)]
let mut scope_1919 = writer.prefix("Tags");
if let Some(var_1920) = &input.tags {
let mut list_1922 = scope_1919.start_list(false, Some("Tag"));
for item_1921 in var_1920 {
#[allow(unused_mut)]
let mut entry_1923 = list_1922.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_1923, item_1921)?;
}
list_1922.finish();
}
#[allow(unused_mut)]
let mut scope_1924 = writer.prefix("StorageType");
if let Some(var_1925) = &input.storage_type {
scope_1924.string(var_1925);
}
#[allow(unused_mut)]
let mut scope_1926 = writer.prefix("TdeCredentialArn");
if let Some(var_1927) = &input.tde_credential_arn {
scope_1926.string(var_1927);
}
#[allow(unused_mut)]
let mut scope_1928 = writer.prefix("TdeCredentialPassword");
if let Some(var_1929) = &input.tde_credential_password {
scope_1928.string(var_1929);
}
#[allow(unused_mut)]
let mut scope_1930 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_1931) = &input.vpc_security_group_ids {
let mut list_1933 = scope_1930.start_list(false, Some("VpcSecurityGroupId"));
for item_1932 in var_1931 {
#[allow(unused_mut)]
let mut entry_1934 = list_1933.entry();
entry_1934.string(item_1932);
}
list_1933.finish();
}
#[allow(unused_mut)]
let mut scope_1935 = writer.prefix("Domain");
if let Some(var_1936) = &input.domain {
scope_1935.string(var_1936);
}
#[allow(unused_mut)]
let mut scope_1937 = writer.prefix("CopyTagsToSnapshot");
if let Some(var_1938) = &input.copy_tags_to_snapshot {
scope_1937.boolean(*var_1938);
}
#[allow(unused_mut)]
let mut scope_1939 = writer.prefix("DomainIAMRoleName");
if let Some(var_1940) = &input.domain_iam_role_name {
scope_1939.string(var_1940);
}
#[allow(unused_mut)]
let mut scope_1941 = writer.prefix("EnableIAMDatabaseAuthentication");
if let Some(var_1942) = &input.enable_iam_database_authentication {
scope_1941.boolean(*var_1942);
}
#[allow(unused_mut)]
let mut scope_1943 = writer.prefix("EnableCloudwatchLogsExports");
if let Some(var_1944) = &input.enable_cloudwatch_logs_exports {
let mut list_1946 = scope_1943.start_list(false, None);
for item_1945 in var_1944 {
#[allow(unused_mut)]
let mut entry_1947 = list_1946.entry();
entry_1947.string(item_1945);
}
list_1946.finish();
}
#[allow(unused_mut)]
let mut scope_1948 = writer.prefix("ProcessorFeatures");
if let Some(var_1949) = &input.processor_features {
let mut list_1951 = scope_1948.start_list(false, Some("ProcessorFeature"));
for item_1950 in var_1949 {
#[allow(unused_mut)]
let mut entry_1952 = list_1951.entry();
crate::query_ser::serialize_structure_crate_model_processor_feature(
entry_1952, item_1950,
)?;
}
list_1951.finish();
}
#[allow(unused_mut)]
let mut scope_1953 = writer.prefix("UseDefaultProcessorFeatures");
if let Some(var_1954) = &input.use_default_processor_features {
scope_1953.boolean(*var_1954);
}
#[allow(unused_mut)]
let mut scope_1955 = writer.prefix("DBParameterGroupName");
if let Some(var_1956) = &input.db_parameter_group_name {
scope_1955.string(var_1956);
}
#[allow(unused_mut)]
let mut scope_1957 = writer.prefix("DeletionProtection");
if let Some(var_1958) = &input.deletion_protection {
scope_1957.boolean(*var_1958);
}
#[allow(unused_mut)]
let mut scope_1959 = writer.prefix("EnableCustomerOwnedIp");
if let Some(var_1960) = &input.enable_customer_owned_ip {
scope_1959.boolean(*var_1960);
}
#[allow(unused_mut)]
let mut scope_1961 = writer.prefix("CustomIamInstanceProfile");
if let Some(var_1962) = &input.custom_iam_instance_profile {
scope_1961.string(var_1962);
}
#[allow(unused_mut)]
let mut scope_1963 = writer.prefix("BackupTarget");
if let Some(var_1964) = &input.backup_target {
scope_1963.string(var_1964);
}
#[allow(unused_mut)]
let mut scope_1965 = writer.prefix("NetworkType");
if let Some(var_1966) = &input.network_type {
scope_1965.string(var_1966);
}
#[allow(unused_mut)]
let mut scope_1967 = writer.prefix("StorageThroughput");
if let Some(var_1968) = &input.storage_throughput {
scope_1967.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1968).into()),
);
}
#[allow(unused_mut)]
let mut scope_1969 = writer.prefix("DBClusterSnapshotIdentifier");
if let Some(var_1970) = &input.db_cluster_snapshot_identifier {
scope_1969.string(var_1970);
}
#[allow(unused_mut)]
let mut scope_1971 = writer.prefix("AllocatedStorage");
if let Some(var_1972) = &input.allocated_storage {
scope_1971.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1972).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_restore_db_instance_from_s3(
input: &crate::input::RestoreDbInstanceFromS3Input,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RestoreDBInstanceFromS3", "2014-10-31");
#[allow(unused_mut)]
let mut scope_1973 = writer.prefix("DBName");
if let Some(var_1974) = &input.db_name {
scope_1973.string(var_1974);
}
#[allow(unused_mut)]
let mut scope_1975 = writer.prefix("DBInstanceIdentifier");
if let Some(var_1976) = &input.db_instance_identifier {
scope_1975.string(var_1976);
}
#[allow(unused_mut)]
let mut scope_1977 = writer.prefix("AllocatedStorage");
if let Some(var_1978) = &input.allocated_storage {
scope_1977.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1978).into()),
);
}
#[allow(unused_mut)]
let mut scope_1979 = writer.prefix("DBInstanceClass");
if let Some(var_1980) = &input.db_instance_class {
scope_1979.string(var_1980);
}
#[allow(unused_mut)]
let mut scope_1981 = writer.prefix("Engine");
if let Some(var_1982) = &input.engine {
scope_1981.string(var_1982);
}
#[allow(unused_mut)]
let mut scope_1983 = writer.prefix("MasterUsername");
if let Some(var_1984) = &input.master_username {
scope_1983.string(var_1984);
}
#[allow(unused_mut)]
let mut scope_1985 = writer.prefix("MasterUserPassword");
if let Some(var_1986) = &input.master_user_password {
scope_1985.string(var_1986);
}
#[allow(unused_mut)]
let mut scope_1987 = writer.prefix("DBSecurityGroups");
if let Some(var_1988) = &input.db_security_groups {
let mut list_1990 = scope_1987.start_list(false, Some("DBSecurityGroupName"));
for item_1989 in var_1988 {
#[allow(unused_mut)]
let mut entry_1991 = list_1990.entry();
entry_1991.string(item_1989);
}
list_1990.finish();
}
#[allow(unused_mut)]
let mut scope_1992 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_1993) = &input.vpc_security_group_ids {
let mut list_1995 = scope_1992.start_list(false, Some("VpcSecurityGroupId"));
for item_1994 in var_1993 {
#[allow(unused_mut)]
let mut entry_1996 = list_1995.entry();
entry_1996.string(item_1994);
}
list_1995.finish();
}
#[allow(unused_mut)]
let mut scope_1997 = writer.prefix("AvailabilityZone");
if let Some(var_1998) = &input.availability_zone {
scope_1997.string(var_1998);
}
#[allow(unused_mut)]
let mut scope_1999 = writer.prefix("DBSubnetGroupName");
if let Some(var_2000) = &input.db_subnet_group_name {
scope_1999.string(var_2000);
}
#[allow(unused_mut)]
let mut scope_2001 = writer.prefix("PreferredMaintenanceWindow");
if let Some(var_2002) = &input.preferred_maintenance_window {
scope_2001.string(var_2002);
}
#[allow(unused_mut)]
let mut scope_2003 = writer.prefix("DBParameterGroupName");
if let Some(var_2004) = &input.db_parameter_group_name {
scope_2003.string(var_2004);
}
#[allow(unused_mut)]
let mut scope_2005 = writer.prefix("BackupRetentionPeriod");
if let Some(var_2006) = &input.backup_retention_period {
scope_2005.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2006).into()),
);
}
#[allow(unused_mut)]
let mut scope_2007 = writer.prefix("PreferredBackupWindow");
if let Some(var_2008) = &input.preferred_backup_window {
scope_2007.string(var_2008);
}
#[allow(unused_mut)]
let mut scope_2009 = writer.prefix("Port");
if let Some(var_2010) = &input.port {
scope_2009.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2010).into()),
);
}
#[allow(unused_mut)]
let mut scope_2011 = writer.prefix("MultiAZ");
if let Some(var_2012) = &input.multi_az {
scope_2011.boolean(*var_2012);
}
#[allow(unused_mut)]
let mut scope_2013 = writer.prefix("EngineVersion");
if let Some(var_2014) = &input.engine_version {
scope_2013.string(var_2014);
}
#[allow(unused_mut)]
let mut scope_2015 = writer.prefix("AutoMinorVersionUpgrade");
if let Some(var_2016) = &input.auto_minor_version_upgrade {
scope_2015.boolean(*var_2016);
}
#[allow(unused_mut)]
let mut scope_2017 = writer.prefix("LicenseModel");
if let Some(var_2018) = &input.license_model {
scope_2017.string(var_2018);
}
#[allow(unused_mut)]
let mut scope_2019 = writer.prefix("Iops");
if let Some(var_2020) = &input.iops {
scope_2019.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2020).into()),
);
}
#[allow(unused_mut)]
let mut scope_2021 = writer.prefix("OptionGroupName");
if let Some(var_2022) = &input.option_group_name {
scope_2021.string(var_2022);
}
#[allow(unused_mut)]
let mut scope_2023 = writer.prefix("PubliclyAccessible");
if let Some(var_2024) = &input.publicly_accessible {
scope_2023.boolean(*var_2024);
}
#[allow(unused_mut)]
let mut scope_2025 = writer.prefix("Tags");
if let Some(var_2026) = &input.tags {
let mut list_2028 = scope_2025.start_list(false, Some("Tag"));
for item_2027 in var_2026 {
#[allow(unused_mut)]
let mut entry_2029 = list_2028.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_2029, item_2027)?;
}
list_2028.finish();
}
#[allow(unused_mut)]
let mut scope_2030 = writer.prefix("StorageType");
if let Some(var_2031) = &input.storage_type {
scope_2030.string(var_2031);
}
#[allow(unused_mut)]
let mut scope_2032 = writer.prefix("StorageEncrypted");
if let Some(var_2033) = &input.storage_encrypted {
scope_2032.boolean(*var_2033);
}
#[allow(unused_mut)]
let mut scope_2034 = writer.prefix("KmsKeyId");
if let Some(var_2035) = &input.kms_key_id {
scope_2034.string(var_2035);
}
#[allow(unused_mut)]
let mut scope_2036 = writer.prefix("CopyTagsToSnapshot");
if let Some(var_2037) = &input.copy_tags_to_snapshot {
scope_2036.boolean(*var_2037);
}
#[allow(unused_mut)]
let mut scope_2038 = writer.prefix("MonitoringInterval");
if let Some(var_2039) = &input.monitoring_interval {
scope_2038.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2039).into()),
);
}
#[allow(unused_mut)]
let mut scope_2040 = writer.prefix("MonitoringRoleArn");
if let Some(var_2041) = &input.monitoring_role_arn {
scope_2040.string(var_2041);
}
#[allow(unused_mut)]
let mut scope_2042 = writer.prefix("EnableIAMDatabaseAuthentication");
if let Some(var_2043) = &input.enable_iam_database_authentication {
scope_2042.boolean(*var_2043);
}
#[allow(unused_mut)]
let mut scope_2044 = writer.prefix("SourceEngine");
if let Some(var_2045) = &input.source_engine {
scope_2044.string(var_2045);
}
#[allow(unused_mut)]
let mut scope_2046 = writer.prefix("SourceEngineVersion");
if let Some(var_2047) = &input.source_engine_version {
scope_2046.string(var_2047);
}
#[allow(unused_mut)]
let mut scope_2048 = writer.prefix("S3BucketName");
if let Some(var_2049) = &input.s3_bucket_name {
scope_2048.string(var_2049);
}
#[allow(unused_mut)]
let mut scope_2050 = writer.prefix("S3Prefix");
if let Some(var_2051) = &input.s3_prefix {
scope_2050.string(var_2051);
}
#[allow(unused_mut)]
let mut scope_2052 = writer.prefix("S3IngestionRoleArn");
if let Some(var_2053) = &input.s3_ingestion_role_arn {
scope_2052.string(var_2053);
}
#[allow(unused_mut)]
let mut scope_2054 = writer.prefix("EnablePerformanceInsights");
if let Some(var_2055) = &input.enable_performance_insights {
scope_2054.boolean(*var_2055);
}
#[allow(unused_mut)]
let mut scope_2056 = writer.prefix("PerformanceInsightsKMSKeyId");
if let Some(var_2057) = &input.performance_insights_kms_key_id {
scope_2056.string(var_2057);
}
#[allow(unused_mut)]
let mut scope_2058 = writer.prefix("PerformanceInsightsRetentionPeriod");
if let Some(var_2059) = &input.performance_insights_retention_period {
scope_2058.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2059).into()),
);
}
#[allow(unused_mut)]
let mut scope_2060 = writer.prefix("EnableCloudwatchLogsExports");
if let Some(var_2061) = &input.enable_cloudwatch_logs_exports {
let mut list_2063 = scope_2060.start_list(false, None);
for item_2062 in var_2061 {
#[allow(unused_mut)]
let mut entry_2064 = list_2063.entry();
entry_2064.string(item_2062);
}
list_2063.finish();
}
#[allow(unused_mut)]
let mut scope_2065 = writer.prefix("ProcessorFeatures");
if let Some(var_2066) = &input.processor_features {
let mut list_2068 = scope_2065.start_list(false, Some("ProcessorFeature"));
for item_2067 in var_2066 {
#[allow(unused_mut)]
let mut entry_2069 = list_2068.entry();
crate::query_ser::serialize_structure_crate_model_processor_feature(
entry_2069, item_2067,
)?;
}
list_2068.finish();
}
#[allow(unused_mut)]
let mut scope_2070 = writer.prefix("UseDefaultProcessorFeatures");
if let Some(var_2071) = &input.use_default_processor_features {
scope_2070.boolean(*var_2071);
}
#[allow(unused_mut)]
let mut scope_2072 = writer.prefix("DeletionProtection");
if let Some(var_2073) = &input.deletion_protection {
scope_2072.boolean(*var_2073);
}
#[allow(unused_mut)]
let mut scope_2074 = writer.prefix("MaxAllocatedStorage");
if let Some(var_2075) = &input.max_allocated_storage {
scope_2074.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2075).into()),
);
}
#[allow(unused_mut)]
let mut scope_2076 = writer.prefix("NetworkType");
if let Some(var_2077) = &input.network_type {
scope_2076.string(var_2077);
}
#[allow(unused_mut)]
let mut scope_2078 = writer.prefix("StorageThroughput");
if let Some(var_2079) = &input.storage_throughput {
scope_2078.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2079).into()),
);
}
#[allow(unused_mut)]
let mut scope_2080 = writer.prefix("ManageMasterUserPassword");
if let Some(var_2081) = &input.manage_master_user_password {
scope_2080.boolean(*var_2081);
}
#[allow(unused_mut)]
let mut scope_2082 = writer.prefix("MasterUserSecretKmsKeyId");
if let Some(var_2083) = &input.master_user_secret_kms_key_id {
scope_2082.string(var_2083);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_restore_db_instance_to_point_in_time(
input: &crate::input::RestoreDbInstanceToPointInTimeInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"RestoreDBInstanceToPointInTime",
"2014-10-31",
);
#[allow(unused_mut)]
let mut scope_2084 = writer.prefix("SourceDBInstanceIdentifier");
if let Some(var_2085) = &input.source_db_instance_identifier {
scope_2084.string(var_2085);
}
#[allow(unused_mut)]
let mut scope_2086 = writer.prefix("TargetDBInstanceIdentifier");
if let Some(var_2087) = &input.target_db_instance_identifier {
scope_2086.string(var_2087);
}
#[allow(unused_mut)]
let mut scope_2088 = writer.prefix("RestoreTime");
if let Some(var_2089) = &input.restore_time {
scope_2088.date_time(var_2089, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_2090 = writer.prefix("UseLatestRestorableTime");
if input.use_latest_restorable_time {
scope_2090.boolean(input.use_latest_restorable_time);
}
#[allow(unused_mut)]
let mut scope_2091 = writer.prefix("DBInstanceClass");
if let Some(var_2092) = &input.db_instance_class {
scope_2091.string(var_2092);
}
#[allow(unused_mut)]
let mut scope_2093 = writer.prefix("Port");
if let Some(var_2094) = &input.port {
scope_2093.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2094).into()),
);
}
#[allow(unused_mut)]
let mut scope_2095 = writer.prefix("AvailabilityZone");
if let Some(var_2096) = &input.availability_zone {
scope_2095.string(var_2096);
}
#[allow(unused_mut)]
let mut scope_2097 = writer.prefix("DBSubnetGroupName");
if let Some(var_2098) = &input.db_subnet_group_name {
scope_2097.string(var_2098);
}
#[allow(unused_mut)]
let mut scope_2099 = writer.prefix("MultiAZ");
if let Some(var_2100) = &input.multi_az {
scope_2099.boolean(*var_2100);
}
#[allow(unused_mut)]
let mut scope_2101 = writer.prefix("PubliclyAccessible");
if let Some(var_2102) = &input.publicly_accessible {
scope_2101.boolean(*var_2102);
}
#[allow(unused_mut)]
let mut scope_2103 = writer.prefix("AutoMinorVersionUpgrade");
if let Some(var_2104) = &input.auto_minor_version_upgrade {
scope_2103.boolean(*var_2104);
}
#[allow(unused_mut)]
let mut scope_2105 = writer.prefix("LicenseModel");
if let Some(var_2106) = &input.license_model {
scope_2105.string(var_2106);
}
#[allow(unused_mut)]
let mut scope_2107 = writer.prefix("DBName");
if let Some(var_2108) = &input.db_name {
scope_2107.string(var_2108);
}
#[allow(unused_mut)]
let mut scope_2109 = writer.prefix("Engine");
if let Some(var_2110) = &input.engine {
scope_2109.string(var_2110);
}
#[allow(unused_mut)]
let mut scope_2111 = writer.prefix("Iops");
if let Some(var_2112) = &input.iops {
scope_2111.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2112).into()),
);
}
#[allow(unused_mut)]
let mut scope_2113 = writer.prefix("OptionGroupName");
if let Some(var_2114) = &input.option_group_name {
scope_2113.string(var_2114);
}
#[allow(unused_mut)]
let mut scope_2115 = writer.prefix("CopyTagsToSnapshot");
if let Some(var_2116) = &input.copy_tags_to_snapshot {
scope_2115.boolean(*var_2116);
}
#[allow(unused_mut)]
let mut scope_2117 = writer.prefix("Tags");
if let Some(var_2118) = &input.tags {
let mut list_2120 = scope_2117.start_list(false, Some("Tag"));
for item_2119 in var_2118 {
#[allow(unused_mut)]
let mut entry_2121 = list_2120.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_2121, item_2119)?;
}
list_2120.finish();
}
#[allow(unused_mut)]
let mut scope_2122 = writer.prefix("StorageType");
if let Some(var_2123) = &input.storage_type {
scope_2122.string(var_2123);
}
#[allow(unused_mut)]
let mut scope_2124 = writer.prefix("TdeCredentialArn");
if let Some(var_2125) = &input.tde_credential_arn {
scope_2124.string(var_2125);
}
#[allow(unused_mut)]
let mut scope_2126 = writer.prefix("TdeCredentialPassword");
if let Some(var_2127) = &input.tde_credential_password {
scope_2126.string(var_2127);
}
#[allow(unused_mut)]
let mut scope_2128 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_2129) = &input.vpc_security_group_ids {
let mut list_2131 = scope_2128.start_list(false, Some("VpcSecurityGroupId"));
for item_2130 in var_2129 {
#[allow(unused_mut)]
let mut entry_2132 = list_2131.entry();
entry_2132.string(item_2130);
}
list_2131.finish();
}
#[allow(unused_mut)]
let mut scope_2133 = writer.prefix("Domain");
if let Some(var_2134) = &input.domain {
scope_2133.string(var_2134);
}
#[allow(unused_mut)]
let mut scope_2135 = writer.prefix("DomainIAMRoleName");
if let Some(var_2136) = &input.domain_iam_role_name {
scope_2135.string(var_2136);
}
#[allow(unused_mut)]
let mut scope_2137 = writer.prefix("EnableIAMDatabaseAuthentication");
if let Some(var_2138) = &input.enable_iam_database_authentication {
scope_2137.boolean(*var_2138);
}
#[allow(unused_mut)]
let mut scope_2139 = writer.prefix("EnableCloudwatchLogsExports");
if let Some(var_2140) = &input.enable_cloudwatch_logs_exports {
let mut list_2142 = scope_2139.start_list(false, None);
for item_2141 in var_2140 {
#[allow(unused_mut)]
let mut entry_2143 = list_2142.entry();
entry_2143.string(item_2141);
}
list_2142.finish();
}
#[allow(unused_mut)]
let mut scope_2144 = writer.prefix("ProcessorFeatures");
if let Some(var_2145) = &input.processor_features {
let mut list_2147 = scope_2144.start_list(false, Some("ProcessorFeature"));
for item_2146 in var_2145 {
#[allow(unused_mut)]
let mut entry_2148 = list_2147.entry();
crate::query_ser::serialize_structure_crate_model_processor_feature(
entry_2148, item_2146,
)?;
}
list_2147.finish();
}
#[allow(unused_mut)]
let mut scope_2149 = writer.prefix("UseDefaultProcessorFeatures");
if let Some(var_2150) = &input.use_default_processor_features {
scope_2149.boolean(*var_2150);
}
#[allow(unused_mut)]
let mut scope_2151 = writer.prefix("DBParameterGroupName");
if let Some(var_2152) = &input.db_parameter_group_name {
scope_2151.string(var_2152);
}
#[allow(unused_mut)]
let mut scope_2153 = writer.prefix("DeletionProtection");
if let Some(var_2154) = &input.deletion_protection {
scope_2153.boolean(*var_2154);
}
#[allow(unused_mut)]
let mut scope_2155 = writer.prefix("SourceDbiResourceId");
if let Some(var_2156) = &input.source_dbi_resource_id {
scope_2155.string(var_2156);
}
#[allow(unused_mut)]
let mut scope_2157 = writer.prefix("MaxAllocatedStorage");
if let Some(var_2158) = &input.max_allocated_storage {
scope_2157.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2158).into()),
);
}
#[allow(unused_mut)]
let mut scope_2159 = writer.prefix("SourceDBInstanceAutomatedBackupsArn");
if let Some(var_2160) = &input.source_db_instance_automated_backups_arn {
scope_2159.string(var_2160);
}
#[allow(unused_mut)]
let mut scope_2161 = writer.prefix("EnableCustomerOwnedIp");
if let Some(var_2162) = &input.enable_customer_owned_ip {
scope_2161.boolean(*var_2162);
}
#[allow(unused_mut)]
let mut scope_2163 = writer.prefix("CustomIamInstanceProfile");
if let Some(var_2164) = &input.custom_iam_instance_profile {
scope_2163.string(var_2164);
}
#[allow(unused_mut)]
let mut scope_2165 = writer.prefix("BackupTarget");
if let Some(var_2166) = &input.backup_target {
scope_2165.string(var_2166);
}
#[allow(unused_mut)]
let mut scope_2167 = writer.prefix("NetworkType");
if let Some(var_2168) = &input.network_type {
scope_2167.string(var_2168);
}
#[allow(unused_mut)]
let mut scope_2169 = writer.prefix("StorageThroughput");
if let Some(var_2170) = &input.storage_throughput {
scope_2169.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2170).into()),
);
}
#[allow(unused_mut)]
let mut scope_2171 = writer.prefix("AllocatedStorage");
if let Some(var_2172) = &input.allocated_storage {
scope_2171.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2172).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_revoke_db_security_group_ingress(
input: &crate::input::RevokeDbSecurityGroupIngressInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RevokeDBSecurityGroupIngress", "2014-10-31");
#[allow(unused_mut)]
let mut scope_2173 = writer.prefix("DBSecurityGroupName");
if let Some(var_2174) = &input.db_security_group_name {
scope_2173.string(var_2174);
}
#[allow(unused_mut)]
let mut scope_2175 = writer.prefix("CIDRIP");
if let Some(var_2176) = &input.cidrip {
scope_2175.string(var_2176);
}
#[allow(unused_mut)]
let mut scope_2177 = writer.prefix("EC2SecurityGroupName");
if let Some(var_2178) = &input.ec2_security_group_name {
scope_2177.string(var_2178);
}
#[allow(unused_mut)]
let mut scope_2179 = writer.prefix("EC2SecurityGroupId");
if let Some(var_2180) = &input.ec2_security_group_id {
scope_2179.string(var_2180);
}
#[allow(unused_mut)]
let mut scope_2181 = writer.prefix("EC2SecurityGroupOwnerId");
if let Some(var_2182) = &input.ec2_security_group_owner_id {
scope_2181.string(var_2182);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_start_activity_stream(
input: &crate::input::StartActivityStreamInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "StartActivityStream", "2014-10-31");
#[allow(unused_mut)]
let mut scope_2183 = writer.prefix("ResourceArn");
if let Some(var_2184) = &input.resource_arn {
scope_2183.string(var_2184);
}
#[allow(unused_mut)]
let mut scope_2185 = writer.prefix("Mode");
if let Some(var_2186) = &input.mode {
scope_2185.string(var_2186.as_str());
}
#[allow(unused_mut)]
let mut scope_2187 = writer.prefix("KmsKeyId");
if let Some(var_2188) = &input.kms_key_id {
scope_2187.string(var_2188);
}
#[allow(unused_mut)]
let mut scope_2189 = writer.prefix("ApplyImmediately");
if let Some(var_2190) = &input.apply_immediately {
scope_2189.boolean(*var_2190);
}
#[allow(unused_mut)]
let mut scope_2191 = writer.prefix("EngineNativeAuditFieldsIncluded");
if let Some(var_2192) = &input.engine_native_audit_fields_included {
scope_2191.boolean(*var_2192);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_start_db_cluster(
input: &crate::input::StartDbClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "StartDBCluster", "2014-10-31");
#[allow(unused_mut)]
let mut scope_2193 = writer.prefix("DBClusterIdentifier");
if let Some(var_2194) = &input.db_cluster_identifier {
scope_2193.string(var_2194);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_start_db_instance(
input: &crate::input::StartDbInstanceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "StartDBInstance", "2014-10-31");
#[allow(unused_mut)]
let mut scope_2195 = writer.prefix("DBInstanceIdentifier");
if let Some(var_2196) = &input.db_instance_identifier {
scope_2195.string(var_2196);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_start_db_instance_automated_backups_replication(
input: &crate::input::StartDbInstanceAutomatedBackupsReplicationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"StartDBInstanceAutomatedBackupsReplication",
"2014-10-31",
);
#[allow(unused_mut)]
let mut scope_2197 = writer.prefix("SourceDBInstanceArn");
if let Some(var_2198) = &input.source_db_instance_arn {
scope_2197.string(var_2198);
}
#[allow(unused_mut)]
let mut scope_2199 = writer.prefix("BackupRetentionPeriod");
if let Some(var_2200) = &input.backup_retention_period {
scope_2199.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2200).into()),
);
}
#[allow(unused_mut)]
let mut scope_2201 = writer.prefix("KmsKeyId");
if let Some(var_2202) = &input.kms_key_id {
scope_2201.string(var_2202);
}
#[allow(unused_mut)]
let mut scope_2203 = writer.prefix("PreSignedUrl");
if let Some(var_2204) = &input.pre_signed_url {
scope_2203.string(var_2204);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_start_export_task(
input: &crate::input::StartExportTaskInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "StartExportTask", "2014-10-31");
#[allow(unused_mut)]
let mut scope_2205 = writer.prefix("ExportTaskIdentifier");
if let Some(var_2206) = &input.export_task_identifier {
scope_2205.string(var_2206);
}
#[allow(unused_mut)]
let mut scope_2207 = writer.prefix("SourceArn");
if let Some(var_2208) = &input.source_arn {
scope_2207.string(var_2208);
}
#[allow(unused_mut)]
let mut scope_2209 = writer.prefix("S3BucketName");
if let Some(var_2210) = &input.s3_bucket_name {
scope_2209.string(var_2210);
}
#[allow(unused_mut)]
let mut scope_2211 = writer.prefix("IamRoleArn");
if let Some(var_2212) = &input.iam_role_arn {
scope_2211.string(var_2212);
}
#[allow(unused_mut)]
let mut scope_2213 = writer.prefix("KmsKeyId");
if let Some(var_2214) = &input.kms_key_id {
scope_2213.string(var_2214);
}
#[allow(unused_mut)]
let mut scope_2215 = writer.prefix("S3Prefix");
if let Some(var_2216) = &input.s3_prefix {
scope_2215.string(var_2216);
}
#[allow(unused_mut)]
let mut scope_2217 = writer.prefix("ExportOnly");
if let Some(var_2218) = &input.export_only {
let mut list_2220 = scope_2217.start_list(false, None);
for item_2219 in var_2218 {
#[allow(unused_mut)]
let mut entry_2221 = list_2220.entry();
entry_2221.string(item_2219);
}
list_2220.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_stop_activity_stream(
input: &crate::input::StopActivityStreamInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "StopActivityStream", "2014-10-31");
#[allow(unused_mut)]
let mut scope_2222 = writer.prefix("ResourceArn");
if let Some(var_2223) = &input.resource_arn {
scope_2222.string(var_2223);
}
#[allow(unused_mut)]
let mut scope_2224 = writer.prefix("ApplyImmediately");
if let Some(var_2225) = &input.apply_immediately {
scope_2224.boolean(*var_2225);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_stop_db_cluster(
input: &crate::input::StopDbClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "StopDBCluster", "2014-10-31");
#[allow(unused_mut)]
let mut scope_2226 = writer.prefix("DBClusterIdentifier");
if let Some(var_2227) = &input.db_cluster_identifier {
scope_2226.string(var_2227);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_stop_db_instance(
input: &crate::input::StopDbInstanceInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "StopDBInstance", "2014-10-31");
#[allow(unused_mut)]
let mut scope_2228 = writer.prefix("DBInstanceIdentifier");
if let Some(var_2229) = &input.db_instance_identifier {
scope_2228.string(var_2229);
}
#[allow(unused_mut)]
let mut scope_2230 = writer.prefix("DBSnapshotIdentifier");
if let Some(var_2231) = &input.db_snapshot_identifier {
scope_2230.string(var_2231);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_stop_db_instance_automated_backups_replication(
input: &crate::input::StopDbInstanceAutomatedBackupsReplicationInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"StopDBInstanceAutomatedBackupsReplication",
"2014-10-31",
);
#[allow(unused_mut)]
let mut scope_2232 = writer.prefix("SourceDBInstanceArn");
if let Some(var_2233) = &input.source_db_instance_arn {
scope_2232.string(var_2233);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_switchover_blue_green_deployment(
input: &crate::input::SwitchoverBlueGreenDeploymentInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "SwitchoverBlueGreenDeployment", "2014-10-31");
#[allow(unused_mut)]
let mut scope_2234 = writer.prefix("BlueGreenDeploymentIdentifier");
if let Some(var_2235) = &input.blue_green_deployment_identifier {
scope_2234.string(var_2235);
}
#[allow(unused_mut)]
let mut scope_2236 = writer.prefix("SwitchoverTimeout");
if let Some(var_2237) = &input.switchover_timeout {
scope_2236.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_2237).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_switchover_read_replica(
input: &crate::input::SwitchoverReadReplicaInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "SwitchoverReadReplica", "2014-10-31");
#[allow(unused_mut)]
let mut scope_2238 = writer.prefix("DBInstanceIdentifier");
if let Some(var_2239) = &input.db_instance_identifier {
scope_2238.string(var_2239);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}