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_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_7 = writer.prefix("SubscriptionName");
if let Some(var_8) = &input.subscription_name {
scope_7.string(var_8);
}
#[allow(unused_mut)]
let mut scope_9 = writer.prefix("SourceIdentifier");
if let Some(var_10) = &input.source_identifier {
scope_9.string(var_10);
}
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_11 = writer.prefix("ResourceName");
if let Some(var_12) = &input.resource_name {
scope_11.string(var_12);
}
#[allow(unused_mut)]
let mut scope_13 = writer.prefix("Tags");
if let Some(var_14) = &input.tags {
let mut list_16 = scope_13.start_list(false, Some("Tag"));
for item_15 in var_14 {
#[allow(unused_mut)]
let mut entry_17 = list_16.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_17, item_15)?;
}
list_16.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_18 = writer.prefix("ResourceIdentifier");
if let Some(var_19) = &input.resource_identifier {
scope_18.string(var_19);
}
#[allow(unused_mut)]
let mut scope_20 = writer.prefix("ApplyAction");
if let Some(var_21) = &input.apply_action {
scope_20.string(var_21);
}
#[allow(unused_mut)]
let mut scope_22 = writer.prefix("OptInType");
if let Some(var_23) = &input.opt_in_type {
scope_22.string(var_23);
}
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_24 = writer.prefix("SourceDBClusterParameterGroupIdentifier");
if let Some(var_25) = &input.source_db_cluster_parameter_group_identifier {
scope_24.string(var_25);
}
#[allow(unused_mut)]
let mut scope_26 = writer.prefix("TargetDBClusterParameterGroupIdentifier");
if let Some(var_27) = &input.target_db_cluster_parameter_group_identifier {
scope_26.string(var_27);
}
#[allow(unused_mut)]
let mut scope_28 = writer.prefix("TargetDBClusterParameterGroupDescription");
if let Some(var_29) = &input.target_db_cluster_parameter_group_description {
scope_28.string(var_29);
}
#[allow(unused_mut)]
let mut scope_30 = writer.prefix("Tags");
if let Some(var_31) = &input.tags {
let mut list_33 = scope_30.start_list(false, Some("Tag"));
for item_32 in var_31 {
#[allow(unused_mut)]
let mut entry_34 = list_33.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_34, item_32)?;
}
list_33.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_35 = writer.prefix("SourceDBClusterSnapshotIdentifier");
if let Some(var_36) = &input.source_db_cluster_snapshot_identifier {
scope_35.string(var_36);
}
#[allow(unused_mut)]
let mut scope_37 = writer.prefix("TargetDBClusterSnapshotIdentifier");
if let Some(var_38) = &input.target_db_cluster_snapshot_identifier {
scope_37.string(var_38);
}
#[allow(unused_mut)]
let mut scope_39 = writer.prefix("KmsKeyId");
if let Some(var_40) = &input.kms_key_id {
scope_39.string(var_40);
}
#[allow(unused_mut)]
let mut scope_41 = writer.prefix("PreSignedUrl");
if let Some(var_42) = &input.pre_signed_url {
scope_41.string(var_42);
}
#[allow(unused_mut)]
let mut scope_43 = writer.prefix("CopyTags");
if let Some(var_44) = &input.copy_tags {
scope_43.boolean(*var_44);
}
#[allow(unused_mut)]
let mut scope_45 = writer.prefix("Tags");
if let Some(var_46) = &input.tags {
let mut list_48 = scope_45.start_list(false, Some("Tag"));
for item_47 in var_46 {
#[allow(unused_mut)]
let mut entry_49 = list_48.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_49, item_47)?;
}
list_48.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_50 = writer.prefix("SourceDBParameterGroupIdentifier");
if let Some(var_51) = &input.source_db_parameter_group_identifier {
scope_50.string(var_51);
}
#[allow(unused_mut)]
let mut scope_52 = writer.prefix("TargetDBParameterGroupIdentifier");
if let Some(var_53) = &input.target_db_parameter_group_identifier {
scope_52.string(var_53);
}
#[allow(unused_mut)]
let mut scope_54 = writer.prefix("TargetDBParameterGroupDescription");
if let Some(var_55) = &input.target_db_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_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_61 = writer.prefix("AvailabilityZones");
if let Some(var_62) = &input.availability_zones {
let mut list_64 = scope_61.start_list(false, Some("AvailabilityZone"));
for item_63 in var_62 {
#[allow(unused_mut)]
let mut entry_65 = list_64.entry();
entry_65.string(item_63);
}
list_64.finish();
}
#[allow(unused_mut)]
let mut scope_66 = writer.prefix("BackupRetentionPeriod");
if let Some(var_67) = &input.backup_retention_period {
scope_66.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_67).into()),
);
}
#[allow(unused_mut)]
let mut scope_68 = writer.prefix("CharacterSetName");
if let Some(var_69) = &input.character_set_name {
scope_68.string(var_69);
}
#[allow(unused_mut)]
let mut scope_70 = writer.prefix("CopyTagsToSnapshot");
if let Some(var_71) = &input.copy_tags_to_snapshot {
scope_70.boolean(*var_71);
}
#[allow(unused_mut)]
let mut scope_72 = writer.prefix("DatabaseName");
if let Some(var_73) = &input.database_name {
scope_72.string(var_73);
}
#[allow(unused_mut)]
let mut scope_74 = writer.prefix("DBClusterIdentifier");
if let Some(var_75) = &input.db_cluster_identifier {
scope_74.string(var_75);
}
#[allow(unused_mut)]
let mut scope_76 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_77) = &input.db_cluster_parameter_group_name {
scope_76.string(var_77);
}
#[allow(unused_mut)]
let mut scope_78 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_79) = &input.vpc_security_group_ids {
let mut list_81 = scope_78.start_list(false, Some("VpcSecurityGroupId"));
for item_80 in var_79 {
#[allow(unused_mut)]
let mut entry_82 = list_81.entry();
entry_82.string(item_80);
}
list_81.finish();
}
#[allow(unused_mut)]
let mut scope_83 = writer.prefix("DBSubnetGroupName");
if let Some(var_84) = &input.db_subnet_group_name {
scope_83.string(var_84);
}
#[allow(unused_mut)]
let mut scope_85 = writer.prefix("Engine");
if let Some(var_86) = &input.engine {
scope_85.string(var_86);
}
#[allow(unused_mut)]
let mut scope_87 = writer.prefix("EngineVersion");
if let Some(var_88) = &input.engine_version {
scope_87.string(var_88);
}
#[allow(unused_mut)]
let mut scope_89 = writer.prefix("Port");
if let Some(var_90) = &input.port {
scope_89.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_90).into()),
);
}
#[allow(unused_mut)]
let mut scope_91 = writer.prefix("MasterUsername");
if let Some(var_92) = &input.master_username {
scope_91.string(var_92);
}
#[allow(unused_mut)]
let mut scope_93 = writer.prefix("MasterUserPassword");
if let Some(var_94) = &input.master_user_password {
scope_93.string(var_94);
}
#[allow(unused_mut)]
let mut scope_95 = writer.prefix("OptionGroupName");
if let Some(var_96) = &input.option_group_name {
scope_95.string(var_96);
}
#[allow(unused_mut)]
let mut scope_97 = writer.prefix("PreferredBackupWindow");
if let Some(var_98) = &input.preferred_backup_window {
scope_97.string(var_98);
}
#[allow(unused_mut)]
let mut scope_99 = writer.prefix("PreferredMaintenanceWindow");
if let Some(var_100) = &input.preferred_maintenance_window {
scope_99.string(var_100);
}
#[allow(unused_mut)]
let mut scope_101 = writer.prefix("ReplicationSourceIdentifier");
if let Some(var_102) = &input.replication_source_identifier {
scope_101.string(var_102);
}
#[allow(unused_mut)]
let mut scope_103 = writer.prefix("Tags");
if let Some(var_104) = &input.tags {
let mut list_106 = scope_103.start_list(false, Some("Tag"));
for item_105 in var_104 {
#[allow(unused_mut)]
let mut entry_107 = list_106.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_107, item_105)?;
}
list_106.finish();
}
#[allow(unused_mut)]
let mut scope_108 = writer.prefix("StorageEncrypted");
if let Some(var_109) = &input.storage_encrypted {
scope_108.boolean(*var_109);
}
#[allow(unused_mut)]
let mut scope_110 = writer.prefix("KmsKeyId");
if let Some(var_111) = &input.kms_key_id {
scope_110.string(var_111);
}
#[allow(unused_mut)]
let mut scope_112 = writer.prefix("PreSignedUrl");
if let Some(var_113) = &input.pre_signed_url {
scope_112.string(var_113);
}
#[allow(unused_mut)]
let mut scope_114 = writer.prefix("EnableIAMDatabaseAuthentication");
if let Some(var_115) = &input.enable_iam_database_authentication {
scope_114.boolean(*var_115);
}
#[allow(unused_mut)]
let mut scope_116 = writer.prefix("EnableCloudwatchLogsExports");
if let Some(var_117) = &input.enable_cloudwatch_logs_exports {
let mut list_119 = scope_116.start_list(false, None);
for item_118 in var_117 {
#[allow(unused_mut)]
let mut entry_120 = list_119.entry();
entry_120.string(item_118);
}
list_119.finish();
}
#[allow(unused_mut)]
let mut scope_121 = writer.prefix("DeletionProtection");
if let Some(var_122) = &input.deletion_protection {
scope_121.boolean(*var_122);
}
#[allow(unused_mut)]
let mut scope_123 = writer.prefix("ServerlessV2ScalingConfiguration");
if let Some(var_124) = &input.serverless_v2_scaling_configuration {
crate::query_ser::serialize_structure_crate_model_serverless_v2_scaling_configuration(
scope_123, var_124,
)?;
}
#[allow(unused_mut)]
let mut scope_125 = writer.prefix("GlobalClusterIdentifier");
if let Some(var_126) = &input.global_cluster_identifier {
scope_125.string(var_126);
}
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_127 = writer.prefix("DBClusterIdentifier");
if let Some(var_128) = &input.db_cluster_identifier {
scope_127.string(var_128);
}
#[allow(unused_mut)]
let mut scope_129 = writer.prefix("DBClusterEndpointIdentifier");
if let Some(var_130) = &input.db_cluster_endpoint_identifier {
scope_129.string(var_130);
}
#[allow(unused_mut)]
let mut scope_131 = writer.prefix("EndpointType");
if let Some(var_132) = &input.endpoint_type {
scope_131.string(var_132);
}
#[allow(unused_mut)]
let mut scope_133 = writer.prefix("StaticMembers");
if let Some(var_134) = &input.static_members {
let mut list_136 = scope_133.start_list(false, None);
for item_135 in var_134 {
#[allow(unused_mut)]
let mut entry_137 = list_136.entry();
entry_137.string(item_135);
}
list_136.finish();
}
#[allow(unused_mut)]
let mut scope_138 = writer.prefix("ExcludedMembers");
if let Some(var_139) = &input.excluded_members {
let mut list_141 = scope_138.start_list(false, None);
for item_140 in var_139 {
#[allow(unused_mut)]
let mut entry_142 = list_141.entry();
entry_142.string(item_140);
}
list_141.finish();
}
#[allow(unused_mut)]
let mut scope_143 = writer.prefix("Tags");
if let Some(var_144) = &input.tags {
let mut list_146 = scope_143.start_list(false, Some("Tag"));
for item_145 in var_144 {
#[allow(unused_mut)]
let mut entry_147 = list_146.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_147, item_145)?;
}
list_146.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_148 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_149) = &input.db_cluster_parameter_group_name {
scope_148.string(var_149);
}
#[allow(unused_mut)]
let mut scope_150 = writer.prefix("DBParameterGroupFamily");
if let Some(var_151) = &input.db_parameter_group_family {
scope_150.string(var_151);
}
#[allow(unused_mut)]
let mut scope_152 = writer.prefix("Description");
if let Some(var_153) = &input.description {
scope_152.string(var_153);
}
#[allow(unused_mut)]
let mut scope_154 = writer.prefix("Tags");
if let Some(var_155) = &input.tags {
let mut list_157 = scope_154.start_list(false, Some("Tag"));
for item_156 in var_155 {
#[allow(unused_mut)]
let mut entry_158 = list_157.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_158, item_156)?;
}
list_157.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_159 = writer.prefix("DBClusterSnapshotIdentifier");
if let Some(var_160) = &input.db_cluster_snapshot_identifier {
scope_159.string(var_160);
}
#[allow(unused_mut)]
let mut scope_161 = writer.prefix("DBClusterIdentifier");
if let Some(var_162) = &input.db_cluster_identifier {
scope_161.string(var_162);
}
#[allow(unused_mut)]
let mut scope_163 = writer.prefix("Tags");
if let Some(var_164) = &input.tags {
let mut list_166 = scope_163.start_list(false, Some("Tag"));
for item_165 in var_164 {
#[allow(unused_mut)]
let mut entry_167 = list_166.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_167, item_165)?;
}
list_166.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_168 = writer.prefix("DBName");
if let Some(var_169) = &input.db_name {
scope_168.string(var_169);
}
#[allow(unused_mut)]
let mut scope_170 = writer.prefix("DBInstanceIdentifier");
if let Some(var_171) = &input.db_instance_identifier {
scope_170.string(var_171);
}
#[allow(unused_mut)]
let mut scope_172 = writer.prefix("AllocatedStorage");
if let Some(var_173) = &input.allocated_storage {
scope_172.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_173).into()),
);
}
#[allow(unused_mut)]
let mut scope_174 = writer.prefix("DBInstanceClass");
if let Some(var_175) = &input.db_instance_class {
scope_174.string(var_175);
}
#[allow(unused_mut)]
let mut scope_176 = writer.prefix("Engine");
if let Some(var_177) = &input.engine {
scope_176.string(var_177);
}
#[allow(unused_mut)]
let mut scope_178 = writer.prefix("MasterUsername");
if let Some(var_179) = &input.master_username {
scope_178.string(var_179);
}
#[allow(unused_mut)]
let mut scope_180 = writer.prefix("MasterUserPassword");
if let Some(var_181) = &input.master_user_password {
scope_180.string(var_181);
}
#[allow(unused_mut)]
let mut scope_182 = writer.prefix("DBSecurityGroups");
if let Some(var_183) = &input.db_security_groups {
let mut list_185 = scope_182.start_list(false, Some("DBSecurityGroupName"));
for item_184 in var_183 {
#[allow(unused_mut)]
let mut entry_186 = list_185.entry();
entry_186.string(item_184);
}
list_185.finish();
}
#[allow(unused_mut)]
let mut scope_187 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_188) = &input.vpc_security_group_ids {
let mut list_190 = scope_187.start_list(false, Some("VpcSecurityGroupId"));
for item_189 in var_188 {
#[allow(unused_mut)]
let mut entry_191 = list_190.entry();
entry_191.string(item_189);
}
list_190.finish();
}
#[allow(unused_mut)]
let mut scope_192 = writer.prefix("AvailabilityZone");
if let Some(var_193) = &input.availability_zone {
scope_192.string(var_193);
}
#[allow(unused_mut)]
let mut scope_194 = writer.prefix("DBSubnetGroupName");
if let Some(var_195) = &input.db_subnet_group_name {
scope_194.string(var_195);
}
#[allow(unused_mut)]
let mut scope_196 = writer.prefix("PreferredMaintenanceWindow");
if let Some(var_197) = &input.preferred_maintenance_window {
scope_196.string(var_197);
}
#[allow(unused_mut)]
let mut scope_198 = writer.prefix("DBParameterGroupName");
if let Some(var_199) = &input.db_parameter_group_name {
scope_198.string(var_199);
}
#[allow(unused_mut)]
let mut scope_200 = writer.prefix("BackupRetentionPeriod");
if let Some(var_201) = &input.backup_retention_period {
scope_200.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_201).into()),
);
}
#[allow(unused_mut)]
let mut scope_202 = writer.prefix("PreferredBackupWindow");
if let Some(var_203) = &input.preferred_backup_window {
scope_202.string(var_203);
}
#[allow(unused_mut)]
let mut scope_204 = writer.prefix("Port");
if let Some(var_205) = &input.port {
scope_204.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_205).into()),
);
}
#[allow(unused_mut)]
let mut scope_206 = writer.prefix("MultiAZ");
if let Some(var_207) = &input.multi_az {
scope_206.boolean(*var_207);
}
#[allow(unused_mut)]
let mut scope_208 = writer.prefix("EngineVersion");
if let Some(var_209) = &input.engine_version {
scope_208.string(var_209);
}
#[allow(unused_mut)]
let mut scope_210 = writer.prefix("AutoMinorVersionUpgrade");
if let Some(var_211) = &input.auto_minor_version_upgrade {
scope_210.boolean(*var_211);
}
#[allow(unused_mut)]
let mut scope_212 = writer.prefix("LicenseModel");
if let Some(var_213) = &input.license_model {
scope_212.string(var_213);
}
#[allow(unused_mut)]
let mut scope_214 = writer.prefix("Iops");
if let Some(var_215) = &input.iops {
scope_214.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_215).into()),
);
}
#[allow(unused_mut)]
let mut scope_216 = writer.prefix("OptionGroupName");
if let Some(var_217) = &input.option_group_name {
scope_216.string(var_217);
}
#[allow(unused_mut)]
let mut scope_218 = writer.prefix("CharacterSetName");
if let Some(var_219) = &input.character_set_name {
scope_218.string(var_219);
}
#[allow(unused_mut)]
let mut scope_220 = writer.prefix("PubliclyAccessible");
if let Some(var_221) = &input.publicly_accessible {
scope_220.boolean(*var_221);
}
#[allow(unused_mut)]
let mut scope_222 = writer.prefix("Tags");
if let Some(var_223) = &input.tags {
let mut list_225 = scope_222.start_list(false, Some("Tag"));
for item_224 in var_223 {
#[allow(unused_mut)]
let mut entry_226 = list_225.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_226, item_224)?;
}
list_225.finish();
}
#[allow(unused_mut)]
let mut scope_227 = writer.prefix("DBClusterIdentifier");
if let Some(var_228) = &input.db_cluster_identifier {
scope_227.string(var_228);
}
#[allow(unused_mut)]
let mut scope_229 = writer.prefix("StorageType");
if let Some(var_230) = &input.storage_type {
scope_229.string(var_230);
}
#[allow(unused_mut)]
let mut scope_231 = writer.prefix("TdeCredentialArn");
if let Some(var_232) = &input.tde_credential_arn {
scope_231.string(var_232);
}
#[allow(unused_mut)]
let mut scope_233 = writer.prefix("TdeCredentialPassword");
if let Some(var_234) = &input.tde_credential_password {
scope_233.string(var_234);
}
#[allow(unused_mut)]
let mut scope_235 = writer.prefix("StorageEncrypted");
if let Some(var_236) = &input.storage_encrypted {
scope_235.boolean(*var_236);
}
#[allow(unused_mut)]
let mut scope_237 = writer.prefix("KmsKeyId");
if let Some(var_238) = &input.kms_key_id {
scope_237.string(var_238);
}
#[allow(unused_mut)]
let mut scope_239 = writer.prefix("Domain");
if let Some(var_240) = &input.domain {
scope_239.string(var_240);
}
#[allow(unused_mut)]
let mut scope_241 = writer.prefix("CopyTagsToSnapshot");
if let Some(var_242) = &input.copy_tags_to_snapshot {
scope_241.boolean(*var_242);
}
#[allow(unused_mut)]
let mut scope_243 = writer.prefix("MonitoringInterval");
if let Some(var_244) = &input.monitoring_interval {
scope_243.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_244).into()),
);
}
#[allow(unused_mut)]
let mut scope_245 = writer.prefix("MonitoringRoleArn");
if let Some(var_246) = &input.monitoring_role_arn {
scope_245.string(var_246);
}
#[allow(unused_mut)]
let mut scope_247 = writer.prefix("DomainIAMRoleName");
if let Some(var_248) = &input.domain_iam_role_name {
scope_247.string(var_248);
}
#[allow(unused_mut)]
let mut scope_249 = writer.prefix("PromotionTier");
if let Some(var_250) = &input.promotion_tier {
scope_249.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_250).into()),
);
}
#[allow(unused_mut)]
let mut scope_251 = writer.prefix("Timezone");
if let Some(var_252) = &input.timezone {
scope_251.string(var_252);
}
#[allow(unused_mut)]
let mut scope_253 = writer.prefix("EnableIAMDatabaseAuthentication");
if let Some(var_254) = &input.enable_iam_database_authentication {
scope_253.boolean(*var_254);
}
#[allow(unused_mut)]
let mut scope_255 = writer.prefix("EnablePerformanceInsights");
if let Some(var_256) = &input.enable_performance_insights {
scope_255.boolean(*var_256);
}
#[allow(unused_mut)]
let mut scope_257 = writer.prefix("PerformanceInsightsKMSKeyId");
if let Some(var_258) = &input.performance_insights_kms_key_id {
scope_257.string(var_258);
}
#[allow(unused_mut)]
let mut scope_259 = writer.prefix("EnableCloudwatchLogsExports");
if let Some(var_260) = &input.enable_cloudwatch_logs_exports {
let mut list_262 = scope_259.start_list(false, None);
for item_261 in var_260 {
#[allow(unused_mut)]
let mut entry_263 = list_262.entry();
entry_263.string(item_261);
}
list_262.finish();
}
#[allow(unused_mut)]
let mut scope_264 = writer.prefix("DeletionProtection");
if let Some(var_265) = &input.deletion_protection {
scope_264.boolean(*var_265);
}
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_266 = writer.prefix("DBParameterGroupName");
if let Some(var_267) = &input.db_parameter_group_name {
scope_266.string(var_267);
}
#[allow(unused_mut)]
let mut scope_268 = writer.prefix("DBParameterGroupFamily");
if let Some(var_269) = &input.db_parameter_group_family {
scope_268.string(var_269);
}
#[allow(unused_mut)]
let mut scope_270 = writer.prefix("Description");
if let Some(var_271) = &input.description {
scope_270.string(var_271);
}
#[allow(unused_mut)]
let mut scope_272 = writer.prefix("Tags");
if let Some(var_273) = &input.tags {
let mut list_275 = scope_272.start_list(false, Some("Tag"));
for item_274 in var_273 {
#[allow(unused_mut)]
let mut entry_276 = list_275.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_276, item_274)?;
}
list_275.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_277 = writer.prefix("DBSubnetGroupName");
if let Some(var_278) = &input.db_subnet_group_name {
scope_277.string(var_278);
}
#[allow(unused_mut)]
let mut scope_279 = writer.prefix("DBSubnetGroupDescription");
if let Some(var_280) = &input.db_subnet_group_description {
scope_279.string(var_280);
}
#[allow(unused_mut)]
let mut scope_281 = writer.prefix("SubnetIds");
if let Some(var_282) = &input.subnet_ids {
let mut list_284 = scope_281.start_list(false, Some("SubnetIdentifier"));
for item_283 in var_282 {
#[allow(unused_mut)]
let mut entry_285 = list_284.entry();
entry_285.string(item_283);
}
list_284.finish();
}
#[allow(unused_mut)]
let mut scope_286 = writer.prefix("Tags");
if let Some(var_287) = &input.tags {
let mut list_289 = scope_286.start_list(false, Some("Tag"));
for item_288 in var_287 {
#[allow(unused_mut)]
let mut entry_290 = list_289.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_290, item_288)?;
}
list_289.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_291 = writer.prefix("SubscriptionName");
if let Some(var_292) = &input.subscription_name {
scope_291.string(var_292);
}
#[allow(unused_mut)]
let mut scope_293 = writer.prefix("SnsTopicArn");
if let Some(var_294) = &input.sns_topic_arn {
scope_293.string(var_294);
}
#[allow(unused_mut)]
let mut scope_295 = writer.prefix("SourceType");
if let Some(var_296) = &input.source_type {
scope_295.string(var_296);
}
#[allow(unused_mut)]
let mut scope_297 = writer.prefix("EventCategories");
if let Some(var_298) = &input.event_categories {
let mut list_300 = scope_297.start_list(false, Some("EventCategory"));
for item_299 in var_298 {
#[allow(unused_mut)]
let mut entry_301 = list_300.entry();
entry_301.string(item_299);
}
list_300.finish();
}
#[allow(unused_mut)]
let mut scope_302 = writer.prefix("SourceIds");
if let Some(var_303) = &input.source_ids {
let mut list_305 = scope_302.start_list(false, Some("SourceId"));
for item_304 in var_303 {
#[allow(unused_mut)]
let mut entry_306 = list_305.entry();
entry_306.string(item_304);
}
list_305.finish();
}
#[allow(unused_mut)]
let mut scope_307 = writer.prefix("Enabled");
if let Some(var_308) = &input.enabled {
scope_307.boolean(*var_308);
}
#[allow(unused_mut)]
let mut scope_309 = writer.prefix("Tags");
if let Some(var_310) = &input.tags {
let mut list_312 = scope_309.start_list(false, Some("Tag"));
for item_311 in var_310 {
#[allow(unused_mut)]
let mut entry_313 = list_312.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_313, item_311)?;
}
list_312.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_314 = writer.prefix("GlobalClusterIdentifier");
if let Some(var_315) = &input.global_cluster_identifier {
scope_314.string(var_315);
}
#[allow(unused_mut)]
let mut scope_316 = writer.prefix("SourceDBClusterIdentifier");
if let Some(var_317) = &input.source_db_cluster_identifier {
scope_316.string(var_317);
}
#[allow(unused_mut)]
let mut scope_318 = writer.prefix("Engine");
if let Some(var_319) = &input.engine {
scope_318.string(var_319);
}
#[allow(unused_mut)]
let mut scope_320 = writer.prefix("EngineVersion");
if let Some(var_321) = &input.engine_version {
scope_320.string(var_321);
}
#[allow(unused_mut)]
let mut scope_322 = writer.prefix("DeletionProtection");
if let Some(var_323) = &input.deletion_protection {
scope_322.boolean(*var_323);
}
#[allow(unused_mut)]
let mut scope_324 = writer.prefix("StorageEncrypted");
if let Some(var_325) = &input.storage_encrypted {
scope_324.boolean(*var_325);
}
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_326 = writer.prefix("DBClusterIdentifier");
if let Some(var_327) = &input.db_cluster_identifier {
scope_326.string(var_327);
}
#[allow(unused_mut)]
let mut scope_328 = writer.prefix("SkipFinalSnapshot");
if input.skip_final_snapshot {
scope_328.boolean(input.skip_final_snapshot);
}
#[allow(unused_mut)]
let mut scope_329 = writer.prefix("FinalDBSnapshotIdentifier");
if let Some(var_330) = &input.final_db_snapshot_identifier {
scope_329.string(var_330);
}
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_331 = writer.prefix("DBClusterEndpointIdentifier");
if let Some(var_332) = &input.db_cluster_endpoint_identifier {
scope_331.string(var_332);
}
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_333 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_334) = &input.db_cluster_parameter_group_name {
scope_333.string(var_334);
}
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_335 = writer.prefix("DBClusterSnapshotIdentifier");
if let Some(var_336) = &input.db_cluster_snapshot_identifier {
scope_335.string(var_336);
}
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_337 = writer.prefix("DBInstanceIdentifier");
if let Some(var_338) = &input.db_instance_identifier {
scope_337.string(var_338);
}
#[allow(unused_mut)]
let mut scope_339 = writer.prefix("SkipFinalSnapshot");
if input.skip_final_snapshot {
scope_339.boolean(input.skip_final_snapshot);
}
#[allow(unused_mut)]
let mut scope_340 = writer.prefix("FinalDBSnapshotIdentifier");
if let Some(var_341) = &input.final_db_snapshot_identifier {
scope_340.string(var_341);
}
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_342 = writer.prefix("DBParameterGroupName");
if let Some(var_343) = &input.db_parameter_group_name {
scope_342.string(var_343);
}
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_344 = writer.prefix("DBSubnetGroupName");
if let Some(var_345) = &input.db_subnet_group_name {
scope_344.string(var_345);
}
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_346 = writer.prefix("SubscriptionName");
if let Some(var_347) = &input.subscription_name {
scope_346.string(var_347);
}
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_348 = writer.prefix("GlobalClusterIdentifier");
if let Some(var_349) = &input.global_cluster_identifier {
scope_348.string(var_349);
}
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_350 = writer.prefix("DBClusterIdentifier");
if let Some(var_351) = &input.db_cluster_identifier {
scope_350.string(var_351);
}
#[allow(unused_mut)]
let mut scope_352 = writer.prefix("DBClusterEndpointIdentifier");
if let Some(var_353) = &input.db_cluster_endpoint_identifier {
scope_352.string(var_353);
}
#[allow(unused_mut)]
let mut scope_354 = writer.prefix("Filters");
if let Some(var_355) = &input.filters {
let mut list_357 = scope_354.start_list(false, Some("Filter"));
for item_356 in var_355 {
#[allow(unused_mut)]
let mut entry_358 = list_357.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_358, item_356)?;
}
list_357.finish();
}
#[allow(unused_mut)]
let mut scope_359 = writer.prefix("MaxRecords");
if let Some(var_360) = &input.max_records {
scope_359.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_360).into()),
);
}
#[allow(unused_mut)]
let mut scope_361 = writer.prefix("Marker");
if let Some(var_362) = &input.marker {
scope_361.string(var_362);
}
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_363 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_364) = &input.db_cluster_parameter_group_name {
scope_363.string(var_364);
}
#[allow(unused_mut)]
let mut scope_365 = writer.prefix("Filters");
if let Some(var_366) = &input.filters {
let mut list_368 = scope_365.start_list(false, Some("Filter"));
for item_367 in var_366 {
#[allow(unused_mut)]
let mut entry_369 = list_368.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_369, item_367)?;
}
list_368.finish();
}
#[allow(unused_mut)]
let mut scope_370 = writer.prefix("MaxRecords");
if let Some(var_371) = &input.max_records {
scope_370.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_371).into()),
);
}
#[allow(unused_mut)]
let mut scope_372 = writer.prefix("Marker");
if let Some(var_373) = &input.marker {
scope_372.string(var_373);
}
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_374 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_375) = &input.db_cluster_parameter_group_name {
scope_374.string(var_375);
}
#[allow(unused_mut)]
let mut scope_376 = writer.prefix("Source");
if let Some(var_377) = &input.source {
scope_376.string(var_377);
}
#[allow(unused_mut)]
let mut scope_378 = writer.prefix("Filters");
if let Some(var_379) = &input.filters {
let mut list_381 = scope_378.start_list(false, Some("Filter"));
for item_380 in var_379 {
#[allow(unused_mut)]
let mut entry_382 = list_381.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_382, item_380)?;
}
list_381.finish();
}
#[allow(unused_mut)]
let mut scope_383 = writer.prefix("MaxRecords");
if let Some(var_384) = &input.max_records {
scope_383.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_384).into()),
);
}
#[allow(unused_mut)]
let mut scope_385 = writer.prefix("Marker");
if let Some(var_386) = &input.marker {
scope_385.string(var_386);
}
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_387 = writer.prefix("DBClusterIdentifier");
if let Some(var_388) = &input.db_cluster_identifier {
scope_387.string(var_388);
}
#[allow(unused_mut)]
let mut scope_389 = writer.prefix("Filters");
if let Some(var_390) = &input.filters {
let mut list_392 = scope_389.start_list(false, Some("Filter"));
for item_391 in var_390 {
#[allow(unused_mut)]
let mut entry_393 = list_392.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_393, item_391)?;
}
list_392.finish();
}
#[allow(unused_mut)]
let mut scope_394 = writer.prefix("MaxRecords");
if let Some(var_395) = &input.max_records {
scope_394.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_395).into()),
);
}
#[allow(unused_mut)]
let mut scope_396 = writer.prefix("Marker");
if let Some(var_397) = &input.marker {
scope_396.string(var_397);
}
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_398 = writer.prefix("DBClusterSnapshotIdentifier");
if let Some(var_399) = &input.db_cluster_snapshot_identifier {
scope_398.string(var_399);
}
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_400 = writer.prefix("DBClusterIdentifier");
if let Some(var_401) = &input.db_cluster_identifier {
scope_400.string(var_401);
}
#[allow(unused_mut)]
let mut scope_402 = writer.prefix("DBClusterSnapshotIdentifier");
if let Some(var_403) = &input.db_cluster_snapshot_identifier {
scope_402.string(var_403);
}
#[allow(unused_mut)]
let mut scope_404 = writer.prefix("SnapshotType");
if let Some(var_405) = &input.snapshot_type {
scope_404.string(var_405);
}
#[allow(unused_mut)]
let mut scope_406 = writer.prefix("Filters");
if let Some(var_407) = &input.filters {
let mut list_409 = scope_406.start_list(false, Some("Filter"));
for item_408 in var_407 {
#[allow(unused_mut)]
let mut entry_410 = list_409.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_410, item_408)?;
}
list_409.finish();
}
#[allow(unused_mut)]
let mut scope_411 = writer.prefix("MaxRecords");
if let Some(var_412) = &input.max_records {
scope_411.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_412).into()),
);
}
#[allow(unused_mut)]
let mut scope_413 = writer.prefix("Marker");
if let Some(var_414) = &input.marker {
scope_413.string(var_414);
}
#[allow(unused_mut)]
let mut scope_415 = writer.prefix("IncludeShared");
if input.include_shared {
scope_415.boolean(input.include_shared);
}
#[allow(unused_mut)]
let mut scope_416 = writer.prefix("IncludePublic");
if input.include_public {
scope_416.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_417 = writer.prefix("Engine");
if let Some(var_418) = &input.engine {
scope_417.string(var_418);
}
#[allow(unused_mut)]
let mut scope_419 = writer.prefix("EngineVersion");
if let Some(var_420) = &input.engine_version {
scope_419.string(var_420);
}
#[allow(unused_mut)]
let mut scope_421 = writer.prefix("DBParameterGroupFamily");
if let Some(var_422) = &input.db_parameter_group_family {
scope_421.string(var_422);
}
#[allow(unused_mut)]
let mut scope_423 = writer.prefix("Filters");
if let Some(var_424) = &input.filters {
let mut list_426 = scope_423.start_list(false, Some("Filter"));
for item_425 in var_424 {
#[allow(unused_mut)]
let mut entry_427 = list_426.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_427, item_425)?;
}
list_426.finish();
}
#[allow(unused_mut)]
let mut scope_428 = writer.prefix("MaxRecords");
if let Some(var_429) = &input.max_records {
scope_428.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_429).into()),
);
}
#[allow(unused_mut)]
let mut scope_430 = writer.prefix("Marker");
if let Some(var_431) = &input.marker {
scope_430.string(var_431);
}
#[allow(unused_mut)]
let mut scope_432 = writer.prefix("DefaultOnly");
if input.default_only {
scope_432.boolean(input.default_only);
}
#[allow(unused_mut)]
let mut scope_433 = writer.prefix("ListSupportedCharacterSets");
if let Some(var_434) = &input.list_supported_character_sets {
scope_433.boolean(*var_434);
}
#[allow(unused_mut)]
let mut scope_435 = writer.prefix("ListSupportedTimezones");
if let Some(var_436) = &input.list_supported_timezones {
scope_435.boolean(*var_436);
}
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_437 = writer.prefix("DBInstanceIdentifier");
if let Some(var_438) = &input.db_instance_identifier {
scope_437.string(var_438);
}
#[allow(unused_mut)]
let mut scope_439 = writer.prefix("Filters");
if let Some(var_440) = &input.filters {
let mut list_442 = scope_439.start_list(false, Some("Filter"));
for item_441 in var_440 {
#[allow(unused_mut)]
let mut entry_443 = list_442.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_443, item_441)?;
}
list_442.finish();
}
#[allow(unused_mut)]
let mut scope_444 = writer.prefix("MaxRecords");
if let Some(var_445) = &input.max_records {
scope_444.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_445).into()),
);
}
#[allow(unused_mut)]
let mut scope_446 = writer.prefix("Marker");
if let Some(var_447) = &input.marker {
scope_446.string(var_447);
}
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_448 = writer.prefix("DBParameterGroupName");
if let Some(var_449) = &input.db_parameter_group_name {
scope_448.string(var_449);
}
#[allow(unused_mut)]
let mut scope_450 = writer.prefix("Filters");
if let Some(var_451) = &input.filters {
let mut list_453 = scope_450.start_list(false, Some("Filter"));
for item_452 in var_451 {
#[allow(unused_mut)]
let mut entry_454 = list_453.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_454, item_452)?;
}
list_453.finish();
}
#[allow(unused_mut)]
let mut scope_455 = writer.prefix("MaxRecords");
if let Some(var_456) = &input.max_records {
scope_455.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_456).into()),
);
}
#[allow(unused_mut)]
let mut scope_457 = writer.prefix("Marker");
if let Some(var_458) = &input.marker {
scope_457.string(var_458);
}
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_459 = writer.prefix("DBParameterGroupName");
if let Some(var_460) = &input.db_parameter_group_name {
scope_459.string(var_460);
}
#[allow(unused_mut)]
let mut scope_461 = writer.prefix("Source");
if let Some(var_462) = &input.source {
scope_461.string(var_462);
}
#[allow(unused_mut)]
let mut scope_463 = writer.prefix("Filters");
if let Some(var_464) = &input.filters {
let mut list_466 = scope_463.start_list(false, Some("Filter"));
for item_465 in var_464 {
#[allow(unused_mut)]
let mut entry_467 = list_466.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_467, item_465)?;
}
list_466.finish();
}
#[allow(unused_mut)]
let mut scope_468 = writer.prefix("MaxRecords");
if let Some(var_469) = &input.max_records {
scope_468.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_469).into()),
);
}
#[allow(unused_mut)]
let mut scope_470 = writer.prefix("Marker");
if let Some(var_471) = &input.marker {
scope_470.string(var_471);
}
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_472 = writer.prefix("DBSubnetGroupName");
if let Some(var_473) = &input.db_subnet_group_name {
scope_472.string(var_473);
}
#[allow(unused_mut)]
let mut scope_474 = writer.prefix("Filters");
if let Some(var_475) = &input.filters {
let mut list_477 = scope_474.start_list(false, Some("Filter"));
for item_476 in var_475 {
#[allow(unused_mut)]
let mut entry_478 = list_477.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_478, item_476)?;
}
list_477.finish();
}
#[allow(unused_mut)]
let mut scope_479 = writer.prefix("MaxRecords");
if let Some(var_480) = &input.max_records {
scope_479.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_480).into()),
);
}
#[allow(unused_mut)]
let mut scope_481 = writer.prefix("Marker");
if let Some(var_482) = &input.marker {
scope_481.string(var_482);
}
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_483 = writer.prefix("DBParameterGroupFamily");
if let Some(var_484) = &input.db_parameter_group_family {
scope_483.string(var_484);
}
#[allow(unused_mut)]
let mut scope_485 = writer.prefix("Filters");
if let Some(var_486) = &input.filters {
let mut list_488 = scope_485.start_list(false, Some("Filter"));
for item_487 in var_486 {
#[allow(unused_mut)]
let mut entry_489 = list_488.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_489, item_487)?;
}
list_488.finish();
}
#[allow(unused_mut)]
let mut scope_490 = writer.prefix("MaxRecords");
if let Some(var_491) = &input.max_records {
scope_490.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_491).into()),
);
}
#[allow(unused_mut)]
let mut scope_492 = writer.prefix("Marker");
if let Some(var_493) = &input.marker {
scope_492.string(var_493);
}
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_494 = writer.prefix("DBParameterGroupFamily");
if let Some(var_495) = &input.db_parameter_group_family {
scope_494.string(var_495);
}
#[allow(unused_mut)]
let mut scope_496 = writer.prefix("Filters");
if let Some(var_497) = &input.filters {
let mut list_499 = scope_496.start_list(false, Some("Filter"));
for item_498 in var_497 {
#[allow(unused_mut)]
let mut entry_500 = list_499.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_500, item_498)?;
}
list_499.finish();
}
#[allow(unused_mut)]
let mut scope_501 = writer.prefix("MaxRecords");
if let Some(var_502) = &input.max_records {
scope_501.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_502).into()),
);
}
#[allow(unused_mut)]
let mut scope_503 = writer.prefix("Marker");
if let Some(var_504) = &input.marker {
scope_503.string(var_504);
}
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_505 = writer.prefix("SourceType");
if let Some(var_506) = &input.source_type {
scope_505.string(var_506);
}
#[allow(unused_mut)]
let mut scope_507 = writer.prefix("Filters");
if let Some(var_508) = &input.filters {
let mut list_510 = scope_507.start_list(false, Some("Filter"));
for item_509 in var_508 {
#[allow(unused_mut)]
let mut entry_511 = list_510.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_511, item_509)?;
}
list_510.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_512 = writer.prefix("SourceIdentifier");
if let Some(var_513) = &input.source_identifier {
scope_512.string(var_513);
}
#[allow(unused_mut)]
let mut scope_514 = writer.prefix("SourceType");
if let Some(var_515) = &input.source_type {
scope_514.string(var_515.as_str());
}
#[allow(unused_mut)]
let mut scope_516 = writer.prefix("StartTime");
if let Some(var_517) = &input.start_time {
scope_516.date_time(var_517, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_518 = writer.prefix("EndTime");
if let Some(var_519) = &input.end_time {
scope_518.date_time(var_519, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_520 = writer.prefix("Duration");
if let Some(var_521) = &input.duration {
scope_520.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_521).into()),
);
}
#[allow(unused_mut)]
let mut scope_522 = writer.prefix("EventCategories");
if let Some(var_523) = &input.event_categories {
let mut list_525 = scope_522.start_list(false, Some("EventCategory"));
for item_524 in var_523 {
#[allow(unused_mut)]
let mut entry_526 = list_525.entry();
entry_526.string(item_524);
}
list_525.finish();
}
#[allow(unused_mut)]
let mut scope_527 = writer.prefix("Filters");
if let Some(var_528) = &input.filters {
let mut list_530 = scope_527.start_list(false, Some("Filter"));
for item_529 in var_528 {
#[allow(unused_mut)]
let mut entry_531 = list_530.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_531, item_529)?;
}
list_530.finish();
}
#[allow(unused_mut)]
let mut scope_532 = writer.prefix("MaxRecords");
if let Some(var_533) = &input.max_records {
scope_532.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_533).into()),
);
}
#[allow(unused_mut)]
let mut scope_534 = writer.prefix("Marker");
if let Some(var_535) = &input.marker {
scope_534.string(var_535);
}
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_536 = writer.prefix("SubscriptionName");
if let Some(var_537) = &input.subscription_name {
scope_536.string(var_537);
}
#[allow(unused_mut)]
let mut scope_538 = writer.prefix("Filters");
if let Some(var_539) = &input.filters {
let mut list_541 = scope_538.start_list(false, Some("Filter"));
for item_540 in var_539 {
#[allow(unused_mut)]
let mut entry_542 = list_541.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_542, item_540)?;
}
list_541.finish();
}
#[allow(unused_mut)]
let mut scope_543 = writer.prefix("MaxRecords");
if let Some(var_544) = &input.max_records {
scope_543.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_544).into()),
);
}
#[allow(unused_mut)]
let mut scope_545 = writer.prefix("Marker");
if let Some(var_546) = &input.marker {
scope_545.string(var_546);
}
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_547 = writer.prefix("GlobalClusterIdentifier");
if let Some(var_548) = &input.global_cluster_identifier {
scope_547.string(var_548);
}
#[allow(unused_mut)]
let mut scope_549 = writer.prefix("MaxRecords");
if let Some(var_550) = &input.max_records {
scope_549.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_550).into()),
);
}
#[allow(unused_mut)]
let mut scope_551 = writer.prefix("Marker");
if let Some(var_552) = &input.marker {
scope_551.string(var_552);
}
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_553 = writer.prefix("Engine");
if let Some(var_554) = &input.engine {
scope_553.string(var_554);
}
#[allow(unused_mut)]
let mut scope_555 = writer.prefix("EngineVersion");
if let Some(var_556) = &input.engine_version {
scope_555.string(var_556);
}
#[allow(unused_mut)]
let mut scope_557 = writer.prefix("DBInstanceClass");
if let Some(var_558) = &input.db_instance_class {
scope_557.string(var_558);
}
#[allow(unused_mut)]
let mut scope_559 = writer.prefix("LicenseModel");
if let Some(var_560) = &input.license_model {
scope_559.string(var_560);
}
#[allow(unused_mut)]
let mut scope_561 = writer.prefix("Vpc");
if let Some(var_562) = &input.vpc {
scope_561.boolean(*var_562);
}
#[allow(unused_mut)]
let mut scope_563 = writer.prefix("Filters");
if let Some(var_564) = &input.filters {
let mut list_566 = scope_563.start_list(false, Some("Filter"));
for item_565 in var_564 {
#[allow(unused_mut)]
let mut entry_567 = list_566.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_567, item_565)?;
}
list_566.finish();
}
#[allow(unused_mut)]
let mut scope_568 = writer.prefix("MaxRecords");
if let Some(var_569) = &input.max_records {
scope_568.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_569).into()),
);
}
#[allow(unused_mut)]
let mut scope_570 = writer.prefix("Marker");
if let Some(var_571) = &input.marker {
scope_570.string(var_571);
}
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_572 = writer.prefix("ResourceIdentifier");
if let Some(var_573) = &input.resource_identifier {
scope_572.string(var_573);
}
#[allow(unused_mut)]
let mut scope_574 = writer.prefix("Filters");
if let Some(var_575) = &input.filters {
let mut list_577 = scope_574.start_list(false, Some("Filter"));
for item_576 in var_575 {
#[allow(unused_mut)]
let mut entry_578 = list_577.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_578, item_576)?;
}
list_577.finish();
}
#[allow(unused_mut)]
let mut scope_579 = writer.prefix("Marker");
if let Some(var_580) = &input.marker {
scope_579.string(var_580);
}
#[allow(unused_mut)]
let mut scope_581 = writer.prefix("MaxRecords");
if let Some(var_582) = &input.max_records {
scope_581.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_582).into()),
);
}
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_583 = writer.prefix("DBInstanceIdentifier");
if let Some(var_584) = &input.db_instance_identifier {
scope_583.string(var_584);
}
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_585 = writer.prefix("DBClusterIdentifier");
if let Some(var_586) = &input.db_cluster_identifier {
scope_585.string(var_586);
}
#[allow(unused_mut)]
let mut scope_587 = writer.prefix("TargetDBInstanceIdentifier");
if let Some(var_588) = &input.target_db_instance_identifier {
scope_587.string(var_588);
}
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_589 = writer.prefix("GlobalClusterIdentifier");
if let Some(var_590) = &input.global_cluster_identifier {
scope_589.string(var_590);
}
#[allow(unused_mut)]
let mut scope_591 = writer.prefix("TargetDbClusterIdentifier");
if let Some(var_592) = &input.target_db_cluster_identifier {
scope_591.string(var_592);
}
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_593 = writer.prefix("ResourceName");
if let Some(var_594) = &input.resource_name {
scope_593.string(var_594);
}
#[allow(unused_mut)]
let mut scope_595 = writer.prefix("Filters");
if let Some(var_596) = &input.filters {
let mut list_598 = scope_595.start_list(false, Some("Filter"));
for item_597 in var_596 {
#[allow(unused_mut)]
let mut entry_599 = list_598.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_599, item_597)?;
}
list_598.finish();
}
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_600 = writer.prefix("DBClusterIdentifier");
if let Some(var_601) = &input.db_cluster_identifier {
scope_600.string(var_601);
}
#[allow(unused_mut)]
let mut scope_602 = writer.prefix("NewDBClusterIdentifier");
if let Some(var_603) = &input.new_db_cluster_identifier {
scope_602.string(var_603);
}
#[allow(unused_mut)]
let mut scope_604 = writer.prefix("ApplyImmediately");
if input.apply_immediately {
scope_604.boolean(input.apply_immediately);
}
#[allow(unused_mut)]
let mut scope_605 = writer.prefix("BackupRetentionPeriod");
if let Some(var_606) = &input.backup_retention_period {
scope_605.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_606).into()),
);
}
#[allow(unused_mut)]
let mut scope_607 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_608) = &input.db_cluster_parameter_group_name {
scope_607.string(var_608);
}
#[allow(unused_mut)]
let mut scope_609 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_610) = &input.vpc_security_group_ids {
let mut list_612 = scope_609.start_list(false, Some("VpcSecurityGroupId"));
for item_611 in var_610 {
#[allow(unused_mut)]
let mut entry_613 = list_612.entry();
entry_613.string(item_611);
}
list_612.finish();
}
#[allow(unused_mut)]
let mut scope_614 = writer.prefix("Port");
if let Some(var_615) = &input.port {
scope_614.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_615).into()),
);
}
#[allow(unused_mut)]
let mut scope_616 = writer.prefix("MasterUserPassword");
if let Some(var_617) = &input.master_user_password {
scope_616.string(var_617);
}
#[allow(unused_mut)]
let mut scope_618 = writer.prefix("OptionGroupName");
if let Some(var_619) = &input.option_group_name {
scope_618.string(var_619);
}
#[allow(unused_mut)]
let mut scope_620 = writer.prefix("PreferredBackupWindow");
if let Some(var_621) = &input.preferred_backup_window {
scope_620.string(var_621);
}
#[allow(unused_mut)]
let mut scope_622 = writer.prefix("PreferredMaintenanceWindow");
if let Some(var_623) = &input.preferred_maintenance_window {
scope_622.string(var_623);
}
#[allow(unused_mut)]
let mut scope_624 = writer.prefix("EnableIAMDatabaseAuthentication");
if let Some(var_625) = &input.enable_iam_database_authentication {
scope_624.boolean(*var_625);
}
#[allow(unused_mut)]
let mut scope_626 = writer.prefix("CloudwatchLogsExportConfiguration");
if let Some(var_627) = &input.cloudwatch_logs_export_configuration {
crate::query_ser::serialize_structure_crate_model_cloudwatch_logs_export_configuration(
scope_626, var_627,
)?;
}
#[allow(unused_mut)]
let mut scope_628 = writer.prefix("EngineVersion");
if let Some(var_629) = &input.engine_version {
scope_628.string(var_629);
}
#[allow(unused_mut)]
let mut scope_630 = writer.prefix("AllowMajorVersionUpgrade");
if input.allow_major_version_upgrade {
scope_630.boolean(input.allow_major_version_upgrade);
}
#[allow(unused_mut)]
let mut scope_631 = writer.prefix("DBInstanceParameterGroupName");
if let Some(var_632) = &input.db_instance_parameter_group_name {
scope_631.string(var_632);
}
#[allow(unused_mut)]
let mut scope_633 = writer.prefix("DeletionProtection");
if let Some(var_634) = &input.deletion_protection {
scope_633.boolean(*var_634);
}
#[allow(unused_mut)]
let mut scope_635 = writer.prefix("CopyTagsToSnapshot");
if let Some(var_636) = &input.copy_tags_to_snapshot {
scope_635.boolean(*var_636);
}
#[allow(unused_mut)]
let mut scope_637 = writer.prefix("ServerlessV2ScalingConfiguration");
if let Some(var_638) = &input.serverless_v2_scaling_configuration {
crate::query_ser::serialize_structure_crate_model_serverless_v2_scaling_configuration(
scope_637, var_638,
)?;
}
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_639 = writer.prefix("DBClusterEndpointIdentifier");
if let Some(var_640) = &input.db_cluster_endpoint_identifier {
scope_639.string(var_640);
}
#[allow(unused_mut)]
let mut scope_641 = writer.prefix("EndpointType");
if let Some(var_642) = &input.endpoint_type {
scope_641.string(var_642);
}
#[allow(unused_mut)]
let mut scope_643 = writer.prefix("StaticMembers");
if let Some(var_644) = &input.static_members {
let mut list_646 = scope_643.start_list(false, None);
for item_645 in var_644 {
#[allow(unused_mut)]
let mut entry_647 = list_646.entry();
entry_647.string(item_645);
}
list_646.finish();
}
#[allow(unused_mut)]
let mut scope_648 = writer.prefix("ExcludedMembers");
if let Some(var_649) = &input.excluded_members {
let mut list_651 = scope_648.start_list(false, None);
for item_650 in var_649 {
#[allow(unused_mut)]
let mut entry_652 = list_651.entry();
entry_652.string(item_650);
}
list_651.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_653 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_654) = &input.db_cluster_parameter_group_name {
scope_653.string(var_654);
}
#[allow(unused_mut)]
let mut scope_655 = writer.prefix("Parameters");
if let Some(var_656) = &input.parameters {
let mut list_658 = scope_655.start_list(false, Some("Parameter"));
for item_657 in var_656 {
#[allow(unused_mut)]
let mut entry_659 = list_658.entry();
crate::query_ser::serialize_structure_crate_model_parameter(entry_659, item_657)?;
}
list_658.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_660 = writer.prefix("DBClusterSnapshotIdentifier");
if let Some(var_661) = &input.db_cluster_snapshot_identifier {
scope_660.string(var_661);
}
#[allow(unused_mut)]
let mut scope_662 = writer.prefix("AttributeName");
if let Some(var_663) = &input.attribute_name {
scope_662.string(var_663);
}
#[allow(unused_mut)]
let mut scope_664 = writer.prefix("ValuesToAdd");
if let Some(var_665) = &input.values_to_add {
let mut list_667 = scope_664.start_list(false, Some("AttributeValue"));
for item_666 in var_665 {
#[allow(unused_mut)]
let mut entry_668 = list_667.entry();
entry_668.string(item_666);
}
list_667.finish();
}
#[allow(unused_mut)]
let mut scope_669 = writer.prefix("ValuesToRemove");
if let Some(var_670) = &input.values_to_remove {
let mut list_672 = scope_669.start_list(false, Some("AttributeValue"));
for item_671 in var_670 {
#[allow(unused_mut)]
let mut entry_673 = list_672.entry();
entry_673.string(item_671);
}
list_672.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_674 = writer.prefix("DBInstanceIdentifier");
if let Some(var_675) = &input.db_instance_identifier {
scope_674.string(var_675);
}
#[allow(unused_mut)]
let mut scope_676 = writer.prefix("AllocatedStorage");
if let Some(var_677) = &input.allocated_storage {
scope_676.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_677).into()),
);
}
#[allow(unused_mut)]
let mut scope_678 = writer.prefix("DBInstanceClass");
if let Some(var_679) = &input.db_instance_class {
scope_678.string(var_679);
}
#[allow(unused_mut)]
let mut scope_680 = writer.prefix("DBSubnetGroupName");
if let Some(var_681) = &input.db_subnet_group_name {
scope_680.string(var_681);
}
#[allow(unused_mut)]
let mut scope_682 = writer.prefix("DBSecurityGroups");
if let Some(var_683) = &input.db_security_groups {
let mut list_685 = scope_682.start_list(false, Some("DBSecurityGroupName"));
for item_684 in var_683 {
#[allow(unused_mut)]
let mut entry_686 = list_685.entry();
entry_686.string(item_684);
}
list_685.finish();
}
#[allow(unused_mut)]
let mut scope_687 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_688) = &input.vpc_security_group_ids {
let mut list_690 = scope_687.start_list(false, Some("VpcSecurityGroupId"));
for item_689 in var_688 {
#[allow(unused_mut)]
let mut entry_691 = list_690.entry();
entry_691.string(item_689);
}
list_690.finish();
}
#[allow(unused_mut)]
let mut scope_692 = writer.prefix("ApplyImmediately");
if input.apply_immediately {
scope_692.boolean(input.apply_immediately);
}
#[allow(unused_mut)]
let mut scope_693 = writer.prefix("MasterUserPassword");
if let Some(var_694) = &input.master_user_password {
scope_693.string(var_694);
}
#[allow(unused_mut)]
let mut scope_695 = writer.prefix("DBParameterGroupName");
if let Some(var_696) = &input.db_parameter_group_name {
scope_695.string(var_696);
}
#[allow(unused_mut)]
let mut scope_697 = writer.prefix("BackupRetentionPeriod");
if let Some(var_698) = &input.backup_retention_period {
scope_697.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_698).into()),
);
}
#[allow(unused_mut)]
let mut scope_699 = writer.prefix("PreferredBackupWindow");
if let Some(var_700) = &input.preferred_backup_window {
scope_699.string(var_700);
}
#[allow(unused_mut)]
let mut scope_701 = writer.prefix("PreferredMaintenanceWindow");
if let Some(var_702) = &input.preferred_maintenance_window {
scope_701.string(var_702);
}
#[allow(unused_mut)]
let mut scope_703 = writer.prefix("MultiAZ");
if let Some(var_704) = &input.multi_az {
scope_703.boolean(*var_704);
}
#[allow(unused_mut)]
let mut scope_705 = writer.prefix("EngineVersion");
if let Some(var_706) = &input.engine_version {
scope_705.string(var_706);
}
#[allow(unused_mut)]
let mut scope_707 = writer.prefix("AllowMajorVersionUpgrade");
if input.allow_major_version_upgrade {
scope_707.boolean(input.allow_major_version_upgrade);
}
#[allow(unused_mut)]
let mut scope_708 = writer.prefix("AutoMinorVersionUpgrade");
if let Some(var_709) = &input.auto_minor_version_upgrade {
scope_708.boolean(*var_709);
}
#[allow(unused_mut)]
let mut scope_710 = writer.prefix("LicenseModel");
if let Some(var_711) = &input.license_model {
scope_710.string(var_711);
}
#[allow(unused_mut)]
let mut scope_712 = writer.prefix("Iops");
if let Some(var_713) = &input.iops {
scope_712.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_713).into()),
);
}
#[allow(unused_mut)]
let mut scope_714 = writer.prefix("OptionGroupName");
if let Some(var_715) = &input.option_group_name {
scope_714.string(var_715);
}
#[allow(unused_mut)]
let mut scope_716 = writer.prefix("NewDBInstanceIdentifier");
if let Some(var_717) = &input.new_db_instance_identifier {
scope_716.string(var_717);
}
#[allow(unused_mut)]
let mut scope_718 = writer.prefix("StorageType");
if let Some(var_719) = &input.storage_type {
scope_718.string(var_719);
}
#[allow(unused_mut)]
let mut scope_720 = writer.prefix("TdeCredentialArn");
if let Some(var_721) = &input.tde_credential_arn {
scope_720.string(var_721);
}
#[allow(unused_mut)]
let mut scope_722 = writer.prefix("TdeCredentialPassword");
if let Some(var_723) = &input.tde_credential_password {
scope_722.string(var_723);
}
#[allow(unused_mut)]
let mut scope_724 = writer.prefix("CACertificateIdentifier");
if let Some(var_725) = &input.ca_certificate_identifier {
scope_724.string(var_725);
}
#[allow(unused_mut)]
let mut scope_726 = writer.prefix("Domain");
if let Some(var_727) = &input.domain {
scope_726.string(var_727);
}
#[allow(unused_mut)]
let mut scope_728 = writer.prefix("CopyTagsToSnapshot");
if let Some(var_729) = &input.copy_tags_to_snapshot {
scope_728.boolean(*var_729);
}
#[allow(unused_mut)]
let mut scope_730 = writer.prefix("MonitoringInterval");
if let Some(var_731) = &input.monitoring_interval {
scope_730.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_731).into()),
);
}
#[allow(unused_mut)]
let mut scope_732 = writer.prefix("DBPortNumber");
if let Some(var_733) = &input.db_port_number {
scope_732.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_733).into()),
);
}
#[allow(unused_mut)]
let mut scope_734 = writer.prefix("PubliclyAccessible");
if let Some(var_735) = &input.publicly_accessible {
scope_734.boolean(*var_735);
}
#[allow(unused_mut)]
let mut scope_736 = writer.prefix("MonitoringRoleArn");
if let Some(var_737) = &input.monitoring_role_arn {
scope_736.string(var_737);
}
#[allow(unused_mut)]
let mut scope_738 = writer.prefix("DomainIAMRoleName");
if let Some(var_739) = &input.domain_iam_role_name {
scope_738.string(var_739);
}
#[allow(unused_mut)]
let mut scope_740 = writer.prefix("PromotionTier");
if let Some(var_741) = &input.promotion_tier {
scope_740.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_741).into()),
);
}
#[allow(unused_mut)]
let mut scope_742 = writer.prefix("EnableIAMDatabaseAuthentication");
if let Some(var_743) = &input.enable_iam_database_authentication {
scope_742.boolean(*var_743);
}
#[allow(unused_mut)]
let mut scope_744 = writer.prefix("EnablePerformanceInsights");
if let Some(var_745) = &input.enable_performance_insights {
scope_744.boolean(*var_745);
}
#[allow(unused_mut)]
let mut scope_746 = writer.prefix("PerformanceInsightsKMSKeyId");
if let Some(var_747) = &input.performance_insights_kms_key_id {
scope_746.string(var_747);
}
#[allow(unused_mut)]
let mut scope_748 = writer.prefix("CloudwatchLogsExportConfiguration");
if let Some(var_749) = &input.cloudwatch_logs_export_configuration {
crate::query_ser::serialize_structure_crate_model_cloudwatch_logs_export_configuration(
scope_748, var_749,
)?;
}
#[allow(unused_mut)]
let mut scope_750 = writer.prefix("DeletionProtection");
if let Some(var_751) = &input.deletion_protection {
scope_750.boolean(*var_751);
}
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_752 = writer.prefix("DBParameterGroupName");
if let Some(var_753) = &input.db_parameter_group_name {
scope_752.string(var_753);
}
#[allow(unused_mut)]
let mut scope_754 = writer.prefix("Parameters");
if let Some(var_755) = &input.parameters {
let mut list_757 = scope_754.start_list(false, Some("Parameter"));
for item_756 in var_755 {
#[allow(unused_mut)]
let mut entry_758 = list_757.entry();
crate::query_ser::serialize_structure_crate_model_parameter(entry_758, item_756)?;
}
list_757.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_759 = writer.prefix("DBSubnetGroupName");
if let Some(var_760) = &input.db_subnet_group_name {
scope_759.string(var_760);
}
#[allow(unused_mut)]
let mut scope_761 = writer.prefix("DBSubnetGroupDescription");
if let Some(var_762) = &input.db_subnet_group_description {
scope_761.string(var_762);
}
#[allow(unused_mut)]
let mut scope_763 = writer.prefix("SubnetIds");
if let Some(var_764) = &input.subnet_ids {
let mut list_766 = scope_763.start_list(false, Some("SubnetIdentifier"));
for item_765 in var_764 {
#[allow(unused_mut)]
let mut entry_767 = list_766.entry();
entry_767.string(item_765);
}
list_766.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_768 = writer.prefix("SubscriptionName");
if let Some(var_769) = &input.subscription_name {
scope_768.string(var_769);
}
#[allow(unused_mut)]
let mut scope_770 = writer.prefix("SnsTopicArn");
if let Some(var_771) = &input.sns_topic_arn {
scope_770.string(var_771);
}
#[allow(unused_mut)]
let mut scope_772 = writer.prefix("SourceType");
if let Some(var_773) = &input.source_type {
scope_772.string(var_773);
}
#[allow(unused_mut)]
let mut scope_774 = writer.prefix("EventCategories");
if let Some(var_775) = &input.event_categories {
let mut list_777 = scope_774.start_list(false, Some("EventCategory"));
for item_776 in var_775 {
#[allow(unused_mut)]
let mut entry_778 = list_777.entry();
entry_778.string(item_776);
}
list_777.finish();
}
#[allow(unused_mut)]
let mut scope_779 = writer.prefix("Enabled");
if let Some(var_780) = &input.enabled {
scope_779.boolean(*var_780);
}
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_781 = writer.prefix("GlobalClusterIdentifier");
if let Some(var_782) = &input.global_cluster_identifier {
scope_781.string(var_782);
}
#[allow(unused_mut)]
let mut scope_783 = writer.prefix("NewGlobalClusterIdentifier");
if let Some(var_784) = &input.new_global_cluster_identifier {
scope_783.string(var_784);
}
#[allow(unused_mut)]
let mut scope_785 = writer.prefix("DeletionProtection");
if let Some(var_786) = &input.deletion_protection {
scope_785.boolean(*var_786);
}
#[allow(unused_mut)]
let mut scope_787 = writer.prefix("EngineVersion");
if let Some(var_788) = &input.engine_version {
scope_787.string(var_788);
}
#[allow(unused_mut)]
let mut scope_789 = writer.prefix("AllowMajorVersionUpgrade");
if let Some(var_790) = &input.allow_major_version_upgrade {
scope_789.boolean(*var_790);
}
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_791 = writer.prefix("DBClusterIdentifier");
if let Some(var_792) = &input.db_cluster_identifier {
scope_791.string(var_792);
}
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_793 = writer.prefix("DBInstanceIdentifier");
if let Some(var_794) = &input.db_instance_identifier {
scope_793.string(var_794);
}
#[allow(unused_mut)]
let mut scope_795 = writer.prefix("ForceFailover");
if let Some(var_796) = &input.force_failover {
scope_795.boolean(*var_796);
}
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_797 = writer.prefix("GlobalClusterIdentifier");
if let Some(var_798) = &input.global_cluster_identifier {
scope_797.string(var_798);
}
#[allow(unused_mut)]
let mut scope_799 = writer.prefix("DbClusterIdentifier");
if let Some(var_800) = &input.db_cluster_identifier {
scope_799.string(var_800);
}
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_801 = writer.prefix("DBClusterIdentifier");
if let Some(var_802) = &input.db_cluster_identifier {
scope_801.string(var_802);
}
#[allow(unused_mut)]
let mut scope_803 = writer.prefix("RoleArn");
if let Some(var_804) = &input.role_arn {
scope_803.string(var_804);
}
#[allow(unused_mut)]
let mut scope_805 = writer.prefix("FeatureName");
if let Some(var_806) = &input.feature_name {
scope_805.string(var_806);
}
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_807 = writer.prefix("SubscriptionName");
if let Some(var_808) = &input.subscription_name {
scope_807.string(var_808);
}
#[allow(unused_mut)]
let mut scope_809 = writer.prefix("SourceIdentifier");
if let Some(var_810) = &input.source_identifier {
scope_809.string(var_810);
}
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_811 = writer.prefix("ResourceName");
if let Some(var_812) = &input.resource_name {
scope_811.string(var_812);
}
#[allow(unused_mut)]
let mut scope_813 = writer.prefix("TagKeys");
if let Some(var_814) = &input.tag_keys {
let mut list_816 = scope_813.start_list(false, None);
for item_815 in var_814 {
#[allow(unused_mut)]
let mut entry_817 = list_816.entry();
entry_817.string(item_815);
}
list_816.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_818 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_819) = &input.db_cluster_parameter_group_name {
scope_818.string(var_819);
}
#[allow(unused_mut)]
let mut scope_820 = writer.prefix("ResetAllParameters");
if input.reset_all_parameters {
scope_820.boolean(input.reset_all_parameters);
}
#[allow(unused_mut)]
let mut scope_821 = writer.prefix("Parameters");
if let Some(var_822) = &input.parameters {
let mut list_824 = scope_821.start_list(false, Some("Parameter"));
for item_823 in var_822 {
#[allow(unused_mut)]
let mut entry_825 = list_824.entry();
crate::query_ser::serialize_structure_crate_model_parameter(entry_825, item_823)?;
}
list_824.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_826 = writer.prefix("DBParameterGroupName");
if let Some(var_827) = &input.db_parameter_group_name {
scope_826.string(var_827);
}
#[allow(unused_mut)]
let mut scope_828 = writer.prefix("ResetAllParameters");
if input.reset_all_parameters {
scope_828.boolean(input.reset_all_parameters);
}
#[allow(unused_mut)]
let mut scope_829 = writer.prefix("Parameters");
if let Some(var_830) = &input.parameters {
let mut list_832 = scope_829.start_list(false, Some("Parameter"));
for item_831 in var_830 {
#[allow(unused_mut)]
let mut entry_833 = list_832.entry();
crate::query_ser::serialize_structure_crate_model_parameter(entry_833, item_831)?;
}
list_832.finish();
}
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_834 = writer.prefix("AvailabilityZones");
if let Some(var_835) = &input.availability_zones {
let mut list_837 = scope_834.start_list(false, Some("AvailabilityZone"));
for item_836 in var_835 {
#[allow(unused_mut)]
let mut entry_838 = list_837.entry();
entry_838.string(item_836);
}
list_837.finish();
}
#[allow(unused_mut)]
let mut scope_839 = writer.prefix("DBClusterIdentifier");
if let Some(var_840) = &input.db_cluster_identifier {
scope_839.string(var_840);
}
#[allow(unused_mut)]
let mut scope_841 = writer.prefix("SnapshotIdentifier");
if let Some(var_842) = &input.snapshot_identifier {
scope_841.string(var_842);
}
#[allow(unused_mut)]
let mut scope_843 = writer.prefix("Engine");
if let Some(var_844) = &input.engine {
scope_843.string(var_844);
}
#[allow(unused_mut)]
let mut scope_845 = writer.prefix("EngineVersion");
if let Some(var_846) = &input.engine_version {
scope_845.string(var_846);
}
#[allow(unused_mut)]
let mut scope_847 = writer.prefix("Port");
if let Some(var_848) = &input.port {
scope_847.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_848).into()),
);
}
#[allow(unused_mut)]
let mut scope_849 = writer.prefix("DBSubnetGroupName");
if let Some(var_850) = &input.db_subnet_group_name {
scope_849.string(var_850);
}
#[allow(unused_mut)]
let mut scope_851 = writer.prefix("DatabaseName");
if let Some(var_852) = &input.database_name {
scope_851.string(var_852);
}
#[allow(unused_mut)]
let mut scope_853 = writer.prefix("OptionGroupName");
if let Some(var_854) = &input.option_group_name {
scope_853.string(var_854);
}
#[allow(unused_mut)]
let mut scope_855 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_856) = &input.vpc_security_group_ids {
let mut list_858 = scope_855.start_list(false, Some("VpcSecurityGroupId"));
for item_857 in var_856 {
#[allow(unused_mut)]
let mut entry_859 = list_858.entry();
entry_859.string(item_857);
}
list_858.finish();
}
#[allow(unused_mut)]
let mut scope_860 = writer.prefix("Tags");
if let Some(var_861) = &input.tags {
let mut list_863 = scope_860.start_list(false, Some("Tag"));
for item_862 in var_861 {
#[allow(unused_mut)]
let mut entry_864 = list_863.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_864, item_862)?;
}
list_863.finish();
}
#[allow(unused_mut)]
let mut scope_865 = writer.prefix("KmsKeyId");
if let Some(var_866) = &input.kms_key_id {
scope_865.string(var_866);
}
#[allow(unused_mut)]
let mut scope_867 = writer.prefix("EnableIAMDatabaseAuthentication");
if let Some(var_868) = &input.enable_iam_database_authentication {
scope_867.boolean(*var_868);
}
#[allow(unused_mut)]
let mut scope_869 = writer.prefix("EnableCloudwatchLogsExports");
if let Some(var_870) = &input.enable_cloudwatch_logs_exports {
let mut list_872 = scope_869.start_list(false, None);
for item_871 in var_870 {
#[allow(unused_mut)]
let mut entry_873 = list_872.entry();
entry_873.string(item_871);
}
list_872.finish();
}
#[allow(unused_mut)]
let mut scope_874 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_875) = &input.db_cluster_parameter_group_name {
scope_874.string(var_875);
}
#[allow(unused_mut)]
let mut scope_876 = writer.prefix("DeletionProtection");
if let Some(var_877) = &input.deletion_protection {
scope_876.boolean(*var_877);
}
#[allow(unused_mut)]
let mut scope_878 = writer.prefix("CopyTagsToSnapshot");
if let Some(var_879) = &input.copy_tags_to_snapshot {
scope_878.boolean(*var_879);
}
#[allow(unused_mut)]
let mut scope_880 = writer.prefix("ServerlessV2ScalingConfiguration");
if let Some(var_881) = &input.serverless_v2_scaling_configuration {
crate::query_ser::serialize_structure_crate_model_serverless_v2_scaling_configuration(
scope_880, var_881,
)?;
}
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_882 = writer.prefix("DBClusterIdentifier");
if let Some(var_883) = &input.db_cluster_identifier {
scope_882.string(var_883);
}
#[allow(unused_mut)]
let mut scope_884 = writer.prefix("RestoreType");
if let Some(var_885) = &input.restore_type {
scope_884.string(var_885);
}
#[allow(unused_mut)]
let mut scope_886 = writer.prefix("SourceDBClusterIdentifier");
if let Some(var_887) = &input.source_db_cluster_identifier {
scope_886.string(var_887);
}
#[allow(unused_mut)]
let mut scope_888 = writer.prefix("RestoreToTime");
if let Some(var_889) = &input.restore_to_time {
scope_888.date_time(var_889, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_890 = writer.prefix("UseLatestRestorableTime");
if input.use_latest_restorable_time {
scope_890.boolean(input.use_latest_restorable_time);
}
#[allow(unused_mut)]
let mut scope_891 = writer.prefix("Port");
if let Some(var_892) = &input.port {
scope_891.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_892).into()),
);
}
#[allow(unused_mut)]
let mut scope_893 = writer.prefix("DBSubnetGroupName");
if let Some(var_894) = &input.db_subnet_group_name {
scope_893.string(var_894);
}
#[allow(unused_mut)]
let mut scope_895 = writer.prefix("OptionGroupName");
if let Some(var_896) = &input.option_group_name {
scope_895.string(var_896);
}
#[allow(unused_mut)]
let mut scope_897 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_898) = &input.vpc_security_group_ids {
let mut list_900 = scope_897.start_list(false, Some("VpcSecurityGroupId"));
for item_899 in var_898 {
#[allow(unused_mut)]
let mut entry_901 = list_900.entry();
entry_901.string(item_899);
}
list_900.finish();
}
#[allow(unused_mut)]
let mut scope_902 = writer.prefix("Tags");
if let Some(var_903) = &input.tags {
let mut list_905 = scope_902.start_list(false, Some("Tag"));
for item_904 in var_903 {
#[allow(unused_mut)]
let mut entry_906 = list_905.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_906, item_904)?;
}
list_905.finish();
}
#[allow(unused_mut)]
let mut scope_907 = writer.prefix("KmsKeyId");
if let Some(var_908) = &input.kms_key_id {
scope_907.string(var_908);
}
#[allow(unused_mut)]
let mut scope_909 = writer.prefix("EnableIAMDatabaseAuthentication");
if let Some(var_910) = &input.enable_iam_database_authentication {
scope_909.boolean(*var_910);
}
#[allow(unused_mut)]
let mut scope_911 = writer.prefix("EnableCloudwatchLogsExports");
if let Some(var_912) = &input.enable_cloudwatch_logs_exports {
let mut list_914 = scope_911.start_list(false, None);
for item_913 in var_912 {
#[allow(unused_mut)]
let mut entry_915 = list_914.entry();
entry_915.string(item_913);
}
list_914.finish();
}
#[allow(unused_mut)]
let mut scope_916 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_917) = &input.db_cluster_parameter_group_name {
scope_916.string(var_917);
}
#[allow(unused_mut)]
let mut scope_918 = writer.prefix("DeletionProtection");
if let Some(var_919) = &input.deletion_protection {
scope_918.boolean(*var_919);
}
#[allow(unused_mut)]
let mut scope_920 = writer.prefix("ServerlessV2ScalingConfiguration");
if let Some(var_921) = &input.serverless_v2_scaling_configuration {
crate::query_ser::serialize_structure_crate_model_serverless_v2_scaling_configuration(
scope_920, var_921,
)?;
}
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_922 = writer.prefix("DBClusterIdentifier");
if let Some(var_923) = &input.db_cluster_identifier {
scope_922.string(var_923);
}
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_924 = writer.prefix("DBClusterIdentifier");
if let Some(var_925) = &input.db_cluster_identifier {
scope_924.string(var_925);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}