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_1 = writer.prefix("SubscriptionName");
if let Some(var_2) = &input.subscription_name {
scope_1.string(var_2);
}
#[allow(unused_mut)]
let mut scope_3 = writer.prefix("SourceIdentifier");
if let Some(var_4) = &input.source_identifier {
scope_3.string(var_4);
}
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_5 = writer.prefix("ResourceName");
if let Some(var_6) = &input.resource_name {
scope_5.string(var_6);
}
#[allow(unused_mut)]
let mut scope_7 = writer.prefix("Tags");
if let Some(var_8) = &input.tags {
let mut list_10 = scope_7.start_list(false, Some("Tag"));
for item_9 in var_8 {
#[allow(unused_mut)]
let mut entry_11 = list_10.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_11, item_9)?;
}
list_10.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_12 = writer.prefix("ResourceIdentifier");
if let Some(var_13) = &input.resource_identifier {
scope_12.string(var_13);
}
#[allow(unused_mut)]
let mut scope_14 = writer.prefix("ApplyAction");
if let Some(var_15) = &input.apply_action {
scope_14.string(var_15);
}
#[allow(unused_mut)]
let mut scope_16 = writer.prefix("OptInType");
if let Some(var_17) = &input.opt_in_type {
scope_16.string(var_17);
}
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_18 = writer.prefix("SourceDBClusterParameterGroupIdentifier");
if let Some(var_19) = &input.source_db_cluster_parameter_group_identifier {
scope_18.string(var_19);
}
#[allow(unused_mut)]
let mut scope_20 = writer.prefix("TargetDBClusterParameterGroupIdentifier");
if let Some(var_21) = &input.target_db_cluster_parameter_group_identifier {
scope_20.string(var_21);
}
#[allow(unused_mut)]
let mut scope_22 = writer.prefix("TargetDBClusterParameterGroupDescription");
if let Some(var_23) = &input.target_db_cluster_parameter_group_description {
scope_22.string(var_23);
}
#[allow(unused_mut)]
let mut scope_24 = writer.prefix("Tags");
if let Some(var_25) = &input.tags {
let mut list_27 = scope_24.start_list(false, Some("Tag"));
for item_26 in var_25 {
#[allow(unused_mut)]
let mut entry_28 = list_27.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_28, item_26)?;
}
list_27.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_29 = writer.prefix("SourceDBClusterSnapshotIdentifier");
if let Some(var_30) = &input.source_db_cluster_snapshot_identifier {
scope_29.string(var_30);
}
#[allow(unused_mut)]
let mut scope_31 = writer.prefix("TargetDBClusterSnapshotIdentifier");
if let Some(var_32) = &input.target_db_cluster_snapshot_identifier {
scope_31.string(var_32);
}
#[allow(unused_mut)]
let mut scope_33 = writer.prefix("KmsKeyId");
if let Some(var_34) = &input.kms_key_id {
scope_33.string(var_34);
}
#[allow(unused_mut)]
let mut scope_35 = writer.prefix("PreSignedUrl");
if let Some(var_36) = &input.pre_signed_url {
scope_35.string(var_36);
}
#[allow(unused_mut)]
let mut scope_37 = writer.prefix("CopyTags");
if let Some(var_38) = &input.copy_tags {
scope_37.boolean(*var_38);
}
#[allow(unused_mut)]
let mut scope_39 = writer.prefix("Tags");
if let Some(var_40) = &input.tags {
let mut list_42 = scope_39.start_list(false, Some("Tag"));
for item_41 in var_40 {
#[allow(unused_mut)]
let mut entry_43 = list_42.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_43, item_41)?;
}
list_42.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_44 = writer.prefix("AvailabilityZones");
if let Some(var_45) = &input.availability_zones {
let mut list_47 = scope_44.start_list(false, Some("AvailabilityZone"));
for item_46 in var_45 {
#[allow(unused_mut)]
let mut entry_48 = list_47.entry();
entry_48.string(item_46);
}
list_47.finish();
}
#[allow(unused_mut)]
let mut scope_49 = writer.prefix("BackupRetentionPeriod");
if let Some(var_50) = &input.backup_retention_period {
scope_49.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_50).into()),
);
}
#[allow(unused_mut)]
let mut scope_51 = writer.prefix("DBClusterIdentifier");
if let Some(var_52) = &input.db_cluster_identifier {
scope_51.string(var_52);
}
#[allow(unused_mut)]
let mut scope_53 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_54) = &input.db_cluster_parameter_group_name {
scope_53.string(var_54);
}
#[allow(unused_mut)]
let mut scope_55 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_56) = &input.vpc_security_group_ids {
let mut list_58 = scope_55.start_list(false, Some("VpcSecurityGroupId"));
for item_57 in var_56 {
#[allow(unused_mut)]
let mut entry_59 = list_58.entry();
entry_59.string(item_57);
}
list_58.finish();
}
#[allow(unused_mut)]
let mut scope_60 = writer.prefix("DBSubnetGroupName");
if let Some(var_61) = &input.db_subnet_group_name {
scope_60.string(var_61);
}
#[allow(unused_mut)]
let mut scope_62 = writer.prefix("Engine");
if let Some(var_63) = &input.engine {
scope_62.string(var_63);
}
#[allow(unused_mut)]
let mut scope_64 = writer.prefix("EngineVersion");
if let Some(var_65) = &input.engine_version {
scope_64.string(var_65);
}
#[allow(unused_mut)]
let mut scope_66 = writer.prefix("Port");
if let Some(var_67) = &input.port {
scope_66.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_67).into()),
);
}
#[allow(unused_mut)]
let mut scope_68 = writer.prefix("MasterUsername");
if let Some(var_69) = &input.master_username {
scope_68.string(var_69);
}
#[allow(unused_mut)]
let mut scope_70 = writer.prefix("MasterUserPassword");
if let Some(var_71) = &input.master_user_password {
scope_70.string(var_71);
}
#[allow(unused_mut)]
let mut scope_72 = writer.prefix("PreferredBackupWindow");
if let Some(var_73) = &input.preferred_backup_window {
scope_72.string(var_73);
}
#[allow(unused_mut)]
let mut scope_74 = writer.prefix("PreferredMaintenanceWindow");
if let Some(var_75) = &input.preferred_maintenance_window {
scope_74.string(var_75);
}
#[allow(unused_mut)]
let mut scope_76 = writer.prefix("Tags");
if let Some(var_77) = &input.tags {
let mut list_79 = scope_76.start_list(false, Some("Tag"));
for item_78 in var_77 {
#[allow(unused_mut)]
let mut entry_80 = list_79.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_80, item_78)?;
}
list_79.finish();
}
#[allow(unused_mut)]
let mut scope_81 = writer.prefix("StorageEncrypted");
if let Some(var_82) = &input.storage_encrypted {
scope_81.boolean(*var_82);
}
#[allow(unused_mut)]
let mut scope_83 = writer.prefix("KmsKeyId");
if let Some(var_84) = &input.kms_key_id {
scope_83.string(var_84);
}
#[allow(unused_mut)]
let mut scope_85 = writer.prefix("PreSignedUrl");
if let Some(var_86) = &input.pre_signed_url {
scope_85.string(var_86);
}
#[allow(unused_mut)]
let mut scope_87 = writer.prefix("EnableCloudwatchLogsExports");
if let Some(var_88) = &input.enable_cloudwatch_logs_exports {
let mut list_90 = scope_87.start_list(false, None);
for item_89 in var_88 {
#[allow(unused_mut)]
let mut entry_91 = list_90.entry();
entry_91.string(item_89);
}
list_90.finish();
}
#[allow(unused_mut)]
let mut scope_92 = writer.prefix("DeletionProtection");
if let Some(var_93) = &input.deletion_protection {
scope_92.boolean(*var_93);
}
#[allow(unused_mut)]
let mut scope_94 = writer.prefix("GlobalClusterIdentifier");
if let Some(var_95) = &input.global_cluster_identifier {
scope_94.string(var_95);
}
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_96 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_97) = &input.db_cluster_parameter_group_name {
scope_96.string(var_97);
}
#[allow(unused_mut)]
let mut scope_98 = writer.prefix("DBParameterGroupFamily");
if let Some(var_99) = &input.db_parameter_group_family {
scope_98.string(var_99);
}
#[allow(unused_mut)]
let mut scope_100 = writer.prefix("Description");
if let Some(var_101) = &input.description {
scope_100.string(var_101);
}
#[allow(unused_mut)]
let mut scope_102 = writer.prefix("Tags");
if let Some(var_103) = &input.tags {
let mut list_105 = scope_102.start_list(false, Some("Tag"));
for item_104 in var_103 {
#[allow(unused_mut)]
let mut entry_106 = list_105.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_106, item_104)?;
}
list_105.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_107 = writer.prefix("DBClusterSnapshotIdentifier");
if let Some(var_108) = &input.db_cluster_snapshot_identifier {
scope_107.string(var_108);
}
#[allow(unused_mut)]
let mut scope_109 = writer.prefix("DBClusterIdentifier");
if let Some(var_110) = &input.db_cluster_identifier {
scope_109.string(var_110);
}
#[allow(unused_mut)]
let mut scope_111 = writer.prefix("Tags");
if let Some(var_112) = &input.tags {
let mut list_114 = scope_111.start_list(false, Some("Tag"));
for item_113 in var_112 {
#[allow(unused_mut)]
let mut entry_115 = list_114.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_115, item_113)?;
}
list_114.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_116 = writer.prefix("DBInstanceIdentifier");
if let Some(var_117) = &input.db_instance_identifier {
scope_116.string(var_117);
}
#[allow(unused_mut)]
let mut scope_118 = writer.prefix("DBInstanceClass");
if let Some(var_119) = &input.db_instance_class {
scope_118.string(var_119);
}
#[allow(unused_mut)]
let mut scope_120 = writer.prefix("Engine");
if let Some(var_121) = &input.engine {
scope_120.string(var_121);
}
#[allow(unused_mut)]
let mut scope_122 = writer.prefix("AvailabilityZone");
if let Some(var_123) = &input.availability_zone {
scope_122.string(var_123);
}
#[allow(unused_mut)]
let mut scope_124 = writer.prefix("PreferredMaintenanceWindow");
if let Some(var_125) = &input.preferred_maintenance_window {
scope_124.string(var_125);
}
#[allow(unused_mut)]
let mut scope_126 = writer.prefix("AutoMinorVersionUpgrade");
if let Some(var_127) = &input.auto_minor_version_upgrade {
scope_126.boolean(*var_127);
}
#[allow(unused_mut)]
let mut scope_128 = writer.prefix("Tags");
if let Some(var_129) = &input.tags {
let mut list_131 = scope_128.start_list(false, Some("Tag"));
for item_130 in var_129 {
#[allow(unused_mut)]
let mut entry_132 = list_131.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_132, item_130)?;
}
list_131.finish();
}
#[allow(unused_mut)]
let mut scope_133 = writer.prefix("DBClusterIdentifier");
if let Some(var_134) = &input.db_cluster_identifier {
scope_133.string(var_134);
}
#[allow(unused_mut)]
let mut scope_135 = writer.prefix("CopyTagsToSnapshot");
if let Some(var_136) = &input.copy_tags_to_snapshot {
scope_135.boolean(*var_136);
}
#[allow(unused_mut)]
let mut scope_137 = writer.prefix("PromotionTier");
if let Some(var_138) = &input.promotion_tier {
scope_137.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_138).into()),
);
}
#[allow(unused_mut)]
let mut scope_139 = writer.prefix("EnablePerformanceInsights");
if let Some(var_140) = &input.enable_performance_insights {
scope_139.boolean(*var_140);
}
#[allow(unused_mut)]
let mut scope_141 = writer.prefix("PerformanceInsightsKMSKeyId");
if let Some(var_142) = &input.performance_insights_kms_key_id {
scope_141.string(var_142);
}
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_143 = writer.prefix("DBSubnetGroupName");
if let Some(var_144) = &input.db_subnet_group_name {
scope_143.string(var_144);
}
#[allow(unused_mut)]
let mut scope_145 = writer.prefix("DBSubnetGroupDescription");
if let Some(var_146) = &input.db_subnet_group_description {
scope_145.string(var_146);
}
#[allow(unused_mut)]
let mut scope_147 = writer.prefix("SubnetIds");
if let Some(var_148) = &input.subnet_ids {
let mut list_150 = scope_147.start_list(false, Some("SubnetIdentifier"));
for item_149 in var_148 {
#[allow(unused_mut)]
let mut entry_151 = list_150.entry();
entry_151.string(item_149);
}
list_150.finish();
}
#[allow(unused_mut)]
let mut scope_152 = writer.prefix("Tags");
if let Some(var_153) = &input.tags {
let mut list_155 = scope_152.start_list(false, Some("Tag"));
for item_154 in var_153 {
#[allow(unused_mut)]
let mut entry_156 = list_155.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_156, item_154)?;
}
list_155.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_157 = writer.prefix("SubscriptionName");
if let Some(var_158) = &input.subscription_name {
scope_157.string(var_158);
}
#[allow(unused_mut)]
let mut scope_159 = writer.prefix("SnsTopicArn");
if let Some(var_160) = &input.sns_topic_arn {
scope_159.string(var_160);
}
#[allow(unused_mut)]
let mut scope_161 = writer.prefix("SourceType");
if let Some(var_162) = &input.source_type {
scope_161.string(var_162);
}
#[allow(unused_mut)]
let mut scope_163 = writer.prefix("EventCategories");
if let Some(var_164) = &input.event_categories {
let mut list_166 = scope_163.start_list(false, Some("EventCategory"));
for item_165 in var_164 {
#[allow(unused_mut)]
let mut entry_167 = list_166.entry();
entry_167.string(item_165);
}
list_166.finish();
}
#[allow(unused_mut)]
let mut scope_168 = writer.prefix("SourceIds");
if let Some(var_169) = &input.source_ids {
let mut list_171 = scope_168.start_list(false, Some("SourceId"));
for item_170 in var_169 {
#[allow(unused_mut)]
let mut entry_172 = list_171.entry();
entry_172.string(item_170);
}
list_171.finish();
}
#[allow(unused_mut)]
let mut scope_173 = writer.prefix("Enabled");
if let Some(var_174) = &input.enabled {
scope_173.boolean(*var_174);
}
#[allow(unused_mut)]
let mut scope_175 = writer.prefix("Tags");
if let Some(var_176) = &input.tags {
let mut list_178 = scope_175.start_list(false, Some("Tag"));
for item_177 in var_176 {
#[allow(unused_mut)]
let mut entry_179 = list_178.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_179, item_177)?;
}
list_178.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_180 = writer.prefix("GlobalClusterIdentifier");
if let Some(var_181) = &input.global_cluster_identifier {
scope_180.string(var_181);
}
#[allow(unused_mut)]
let mut scope_182 = writer.prefix("SourceDBClusterIdentifier");
if let Some(var_183) = &input.source_db_cluster_identifier {
scope_182.string(var_183);
}
#[allow(unused_mut)]
let mut scope_184 = writer.prefix("Engine");
if let Some(var_185) = &input.engine {
scope_184.string(var_185);
}
#[allow(unused_mut)]
let mut scope_186 = writer.prefix("EngineVersion");
if let Some(var_187) = &input.engine_version {
scope_186.string(var_187);
}
#[allow(unused_mut)]
let mut scope_188 = writer.prefix("DeletionProtection");
if let Some(var_189) = &input.deletion_protection {
scope_188.boolean(*var_189);
}
#[allow(unused_mut)]
let mut scope_190 = writer.prefix("DatabaseName");
if let Some(var_191) = &input.database_name {
scope_190.string(var_191);
}
#[allow(unused_mut)]
let mut scope_192 = writer.prefix("StorageEncrypted");
if let Some(var_193) = &input.storage_encrypted {
scope_192.boolean(*var_193);
}
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_194 = writer.prefix("DBClusterIdentifier");
if let Some(var_195) = &input.db_cluster_identifier {
scope_194.string(var_195);
}
#[allow(unused_mut)]
let mut scope_196 = writer.prefix("SkipFinalSnapshot");
if input.skip_final_snapshot {
scope_196.boolean(input.skip_final_snapshot);
}
#[allow(unused_mut)]
let mut scope_197 = writer.prefix("FinalDBSnapshotIdentifier");
if let Some(var_198) = &input.final_db_snapshot_identifier {
scope_197.string(var_198);
}
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_199 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_200) = &input.db_cluster_parameter_group_name {
scope_199.string(var_200);
}
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_201 = writer.prefix("DBClusterSnapshotIdentifier");
if let Some(var_202) = &input.db_cluster_snapshot_identifier {
scope_201.string(var_202);
}
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_203 = writer.prefix("DBInstanceIdentifier");
if let Some(var_204) = &input.db_instance_identifier {
scope_203.string(var_204);
}
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_205 = writer.prefix("DBSubnetGroupName");
if let Some(var_206) = &input.db_subnet_group_name {
scope_205.string(var_206);
}
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_207 = writer.prefix("SubscriptionName");
if let Some(var_208) = &input.subscription_name {
scope_207.string(var_208);
}
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_209 = writer.prefix("GlobalClusterIdentifier");
if let Some(var_210) = &input.global_cluster_identifier {
scope_209.string(var_210);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_certificates(
input: &crate::input::DescribeCertificatesInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeCertificates", "2014-10-31");
#[allow(unused_mut)]
let mut scope_211 = writer.prefix("CertificateIdentifier");
if let Some(var_212) = &input.certificate_identifier {
scope_211.string(var_212);
}
#[allow(unused_mut)]
let mut scope_213 = writer.prefix("Filters");
if let Some(var_214) = &input.filters {
let mut list_216 = scope_213.start_list(false, Some("Filter"));
for item_215 in var_214 {
#[allow(unused_mut)]
let mut entry_217 = list_216.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_217, item_215)?;
}
list_216.finish();
}
#[allow(unused_mut)]
let mut scope_218 = writer.prefix("MaxRecords");
if let Some(var_219) = &input.max_records {
scope_218.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_219).into()),
);
}
#[allow(unused_mut)]
let mut scope_220 = writer.prefix("Marker");
if let Some(var_221) = &input.marker {
scope_220.string(var_221);
}
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_222 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_223) = &input.db_cluster_parameter_group_name {
scope_222.string(var_223);
}
#[allow(unused_mut)]
let mut scope_224 = writer.prefix("Filters");
if let Some(var_225) = &input.filters {
let mut list_227 = scope_224.start_list(false, Some("Filter"));
for item_226 in var_225 {
#[allow(unused_mut)]
let mut entry_228 = list_227.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_228, item_226)?;
}
list_227.finish();
}
#[allow(unused_mut)]
let mut scope_229 = writer.prefix("MaxRecords");
if let Some(var_230) = &input.max_records {
scope_229.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_230).into()),
);
}
#[allow(unused_mut)]
let mut scope_231 = writer.prefix("Marker");
if let Some(var_232) = &input.marker {
scope_231.string(var_232);
}
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_233 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_234) = &input.db_cluster_parameter_group_name {
scope_233.string(var_234);
}
#[allow(unused_mut)]
let mut scope_235 = writer.prefix("Source");
if let Some(var_236) = &input.source {
scope_235.string(var_236);
}
#[allow(unused_mut)]
let mut scope_237 = writer.prefix("Filters");
if let Some(var_238) = &input.filters {
let mut list_240 = scope_237.start_list(false, Some("Filter"));
for item_239 in var_238 {
#[allow(unused_mut)]
let mut entry_241 = list_240.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_241, item_239)?;
}
list_240.finish();
}
#[allow(unused_mut)]
let mut scope_242 = writer.prefix("MaxRecords");
if let Some(var_243) = &input.max_records {
scope_242.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_243).into()),
);
}
#[allow(unused_mut)]
let mut scope_244 = writer.prefix("Marker");
if let Some(var_245) = &input.marker {
scope_244.string(var_245);
}
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_246 = writer.prefix("DBClusterIdentifier");
if let Some(var_247) = &input.db_cluster_identifier {
scope_246.string(var_247);
}
#[allow(unused_mut)]
let mut scope_248 = writer.prefix("Filters");
if let Some(var_249) = &input.filters {
let mut list_251 = scope_248.start_list(false, Some("Filter"));
for item_250 in var_249 {
#[allow(unused_mut)]
let mut entry_252 = list_251.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_252, item_250)?;
}
list_251.finish();
}
#[allow(unused_mut)]
let mut scope_253 = writer.prefix("MaxRecords");
if let Some(var_254) = &input.max_records {
scope_253.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_254).into()),
);
}
#[allow(unused_mut)]
let mut scope_255 = writer.prefix("Marker");
if let Some(var_256) = &input.marker {
scope_255.string(var_256);
}
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_257 = writer.prefix("DBClusterSnapshotIdentifier");
if let Some(var_258) = &input.db_cluster_snapshot_identifier {
scope_257.string(var_258);
}
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_259 = writer.prefix("DBClusterIdentifier");
if let Some(var_260) = &input.db_cluster_identifier {
scope_259.string(var_260);
}
#[allow(unused_mut)]
let mut scope_261 = writer.prefix("DBClusterSnapshotIdentifier");
if let Some(var_262) = &input.db_cluster_snapshot_identifier {
scope_261.string(var_262);
}
#[allow(unused_mut)]
let mut scope_263 = writer.prefix("SnapshotType");
if let Some(var_264) = &input.snapshot_type {
scope_263.string(var_264);
}
#[allow(unused_mut)]
let mut scope_265 = writer.prefix("Filters");
if let Some(var_266) = &input.filters {
let mut list_268 = scope_265.start_list(false, Some("Filter"));
for item_267 in var_266 {
#[allow(unused_mut)]
let mut entry_269 = list_268.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_269, item_267)?;
}
list_268.finish();
}
#[allow(unused_mut)]
let mut scope_270 = writer.prefix("MaxRecords");
if let Some(var_271) = &input.max_records {
scope_270.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_271).into()),
);
}
#[allow(unused_mut)]
let mut scope_272 = writer.prefix("Marker");
if let Some(var_273) = &input.marker {
scope_272.string(var_273);
}
#[allow(unused_mut)]
let mut scope_274 = writer.prefix("IncludeShared");
if input.include_shared {
scope_274.boolean(input.include_shared);
}
#[allow(unused_mut)]
let mut scope_275 = writer.prefix("IncludePublic");
if input.include_public {
scope_275.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_276 = writer.prefix("Engine");
if let Some(var_277) = &input.engine {
scope_276.string(var_277);
}
#[allow(unused_mut)]
let mut scope_278 = writer.prefix("EngineVersion");
if let Some(var_279) = &input.engine_version {
scope_278.string(var_279);
}
#[allow(unused_mut)]
let mut scope_280 = writer.prefix("DBParameterGroupFamily");
if let Some(var_281) = &input.db_parameter_group_family {
scope_280.string(var_281);
}
#[allow(unused_mut)]
let mut scope_282 = writer.prefix("Filters");
if let Some(var_283) = &input.filters {
let mut list_285 = scope_282.start_list(false, Some("Filter"));
for item_284 in var_283 {
#[allow(unused_mut)]
let mut entry_286 = list_285.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_286, item_284)?;
}
list_285.finish();
}
#[allow(unused_mut)]
let mut scope_287 = writer.prefix("MaxRecords");
if let Some(var_288) = &input.max_records {
scope_287.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_288).into()),
);
}
#[allow(unused_mut)]
let mut scope_289 = writer.prefix("Marker");
if let Some(var_290) = &input.marker {
scope_289.string(var_290);
}
#[allow(unused_mut)]
let mut scope_291 = writer.prefix("DefaultOnly");
if input.default_only {
scope_291.boolean(input.default_only);
}
#[allow(unused_mut)]
let mut scope_292 = writer.prefix("ListSupportedCharacterSets");
if let Some(var_293) = &input.list_supported_character_sets {
scope_292.boolean(*var_293);
}
#[allow(unused_mut)]
let mut scope_294 = writer.prefix("ListSupportedTimezones");
if let Some(var_295) = &input.list_supported_timezones {
scope_294.boolean(*var_295);
}
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_296 = writer.prefix("DBInstanceIdentifier");
if let Some(var_297) = &input.db_instance_identifier {
scope_296.string(var_297);
}
#[allow(unused_mut)]
let mut scope_298 = writer.prefix("Filters");
if let Some(var_299) = &input.filters {
let mut list_301 = scope_298.start_list(false, Some("Filter"));
for item_300 in var_299 {
#[allow(unused_mut)]
let mut entry_302 = list_301.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_302, item_300)?;
}
list_301.finish();
}
#[allow(unused_mut)]
let mut scope_303 = writer.prefix("MaxRecords");
if let Some(var_304) = &input.max_records {
scope_303.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_304).into()),
);
}
#[allow(unused_mut)]
let mut scope_305 = writer.prefix("Marker");
if let Some(var_306) = &input.marker {
scope_305.string(var_306);
}
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_307 = writer.prefix("DBSubnetGroupName");
if let Some(var_308) = &input.db_subnet_group_name {
scope_307.string(var_308);
}
#[allow(unused_mut)]
let mut scope_309 = writer.prefix("Filters");
if let Some(var_310) = &input.filters {
let mut list_312 = scope_309.start_list(false, Some("Filter"));
for item_311 in var_310 {
#[allow(unused_mut)]
let mut entry_313 = list_312.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_313, item_311)?;
}
list_312.finish();
}
#[allow(unused_mut)]
let mut scope_314 = writer.prefix("MaxRecords");
if let Some(var_315) = &input.max_records {
scope_314.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_315).into()),
);
}
#[allow(unused_mut)]
let mut scope_316 = writer.prefix("Marker");
if let Some(var_317) = &input.marker {
scope_316.string(var_317);
}
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_318 = writer.prefix("DBParameterGroupFamily");
if let Some(var_319) = &input.db_parameter_group_family {
scope_318.string(var_319);
}
#[allow(unused_mut)]
let mut scope_320 = writer.prefix("Filters");
if let Some(var_321) = &input.filters {
let mut list_323 = scope_320.start_list(false, Some("Filter"));
for item_322 in var_321 {
#[allow(unused_mut)]
let mut entry_324 = list_323.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_324, item_322)?;
}
list_323.finish();
}
#[allow(unused_mut)]
let mut scope_325 = writer.prefix("MaxRecords");
if let Some(var_326) = &input.max_records {
scope_325.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_326).into()),
);
}
#[allow(unused_mut)]
let mut scope_327 = writer.prefix("Marker");
if let Some(var_328) = &input.marker {
scope_327.string(var_328);
}
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_329 = writer.prefix("SourceType");
if let Some(var_330) = &input.source_type {
scope_329.string(var_330);
}
#[allow(unused_mut)]
let mut scope_331 = writer.prefix("Filters");
if let Some(var_332) = &input.filters {
let mut list_334 = scope_331.start_list(false, Some("Filter"));
for item_333 in var_332 {
#[allow(unused_mut)]
let mut entry_335 = list_334.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_335, item_333)?;
}
list_334.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_336 = writer.prefix("SourceIdentifier");
if let Some(var_337) = &input.source_identifier {
scope_336.string(var_337);
}
#[allow(unused_mut)]
let mut scope_338 = writer.prefix("SourceType");
if let Some(var_339) = &input.source_type {
scope_338.string(var_339.as_str());
}
#[allow(unused_mut)]
let mut scope_340 = writer.prefix("StartTime");
if let Some(var_341) = &input.start_time {
scope_340.date_time(var_341, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_342 = writer.prefix("EndTime");
if let Some(var_343) = &input.end_time {
scope_342.date_time(var_343, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_344 = writer.prefix("Duration");
if let Some(var_345) = &input.duration {
scope_344.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_345).into()),
);
}
#[allow(unused_mut)]
let mut scope_346 = writer.prefix("EventCategories");
if let Some(var_347) = &input.event_categories {
let mut list_349 = scope_346.start_list(false, Some("EventCategory"));
for item_348 in var_347 {
#[allow(unused_mut)]
let mut entry_350 = list_349.entry();
entry_350.string(item_348);
}
list_349.finish();
}
#[allow(unused_mut)]
let mut scope_351 = writer.prefix("Filters");
if let Some(var_352) = &input.filters {
let mut list_354 = scope_351.start_list(false, Some("Filter"));
for item_353 in var_352 {
#[allow(unused_mut)]
let mut entry_355 = list_354.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_355, item_353)?;
}
list_354.finish();
}
#[allow(unused_mut)]
let mut scope_356 = writer.prefix("MaxRecords");
if let Some(var_357) = &input.max_records {
scope_356.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_357).into()),
);
}
#[allow(unused_mut)]
let mut scope_358 = writer.prefix("Marker");
if let Some(var_359) = &input.marker {
scope_358.string(var_359);
}
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_360 = writer.prefix("SubscriptionName");
if let Some(var_361) = &input.subscription_name {
scope_360.string(var_361);
}
#[allow(unused_mut)]
let mut scope_362 = writer.prefix("Filters");
if let Some(var_363) = &input.filters {
let mut list_365 = scope_362.start_list(false, Some("Filter"));
for item_364 in var_363 {
#[allow(unused_mut)]
let mut entry_366 = list_365.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_366, item_364)?;
}
list_365.finish();
}
#[allow(unused_mut)]
let mut scope_367 = writer.prefix("MaxRecords");
if let Some(var_368) = &input.max_records {
scope_367.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_368).into()),
);
}
#[allow(unused_mut)]
let mut scope_369 = writer.prefix("Marker");
if let Some(var_370) = &input.marker {
scope_369.string(var_370);
}
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_371 = writer.prefix("GlobalClusterIdentifier");
if let Some(var_372) = &input.global_cluster_identifier {
scope_371.string(var_372);
}
#[allow(unused_mut)]
let mut scope_373 = writer.prefix("Filters");
if let Some(var_374) = &input.filters {
let mut list_376 = scope_373.start_list(false, Some("Filter"));
for item_375 in var_374 {
#[allow(unused_mut)]
let mut entry_377 = list_376.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_377, item_375)?;
}
list_376.finish();
}
#[allow(unused_mut)]
let mut scope_378 = writer.prefix("MaxRecords");
if let Some(var_379) = &input.max_records {
scope_378.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_379).into()),
);
}
#[allow(unused_mut)]
let mut scope_380 = writer.prefix("Marker");
if let Some(var_381) = &input.marker {
scope_380.string(var_381);
}
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_382 = writer.prefix("Engine");
if let Some(var_383) = &input.engine {
scope_382.string(var_383);
}
#[allow(unused_mut)]
let mut scope_384 = writer.prefix("EngineVersion");
if let Some(var_385) = &input.engine_version {
scope_384.string(var_385);
}
#[allow(unused_mut)]
let mut scope_386 = writer.prefix("DBInstanceClass");
if let Some(var_387) = &input.db_instance_class {
scope_386.string(var_387);
}
#[allow(unused_mut)]
let mut scope_388 = writer.prefix("LicenseModel");
if let Some(var_389) = &input.license_model {
scope_388.string(var_389);
}
#[allow(unused_mut)]
let mut scope_390 = writer.prefix("Vpc");
if let Some(var_391) = &input.vpc {
scope_390.boolean(*var_391);
}
#[allow(unused_mut)]
let mut scope_392 = writer.prefix("Filters");
if let Some(var_393) = &input.filters {
let mut list_395 = scope_392.start_list(false, Some("Filter"));
for item_394 in var_393 {
#[allow(unused_mut)]
let mut entry_396 = list_395.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_396, item_394)?;
}
list_395.finish();
}
#[allow(unused_mut)]
let mut scope_397 = writer.prefix("MaxRecords");
if let Some(var_398) = &input.max_records {
scope_397.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_398).into()),
);
}
#[allow(unused_mut)]
let mut scope_399 = writer.prefix("Marker");
if let Some(var_400) = &input.marker {
scope_399.string(var_400);
}
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_401 = writer.prefix("ResourceIdentifier");
if let Some(var_402) = &input.resource_identifier {
scope_401.string(var_402);
}
#[allow(unused_mut)]
let mut scope_403 = writer.prefix("Filters");
if let Some(var_404) = &input.filters {
let mut list_406 = scope_403.start_list(false, Some("Filter"));
for item_405 in var_404 {
#[allow(unused_mut)]
let mut entry_407 = list_406.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_407, item_405)?;
}
list_406.finish();
}
#[allow(unused_mut)]
let mut scope_408 = writer.prefix("Marker");
if let Some(var_409) = &input.marker {
scope_408.string(var_409);
}
#[allow(unused_mut)]
let mut scope_410 = writer.prefix("MaxRecords");
if let Some(var_411) = &input.max_records {
scope_410.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_411).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_failover_db_cluster(
input: &crate::input::FailoverDbClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, aws_smithy_http::operation::error::SerializationError> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "FailoverDBCluster", "2014-10-31");
#[allow(unused_mut)]
let mut scope_412 = writer.prefix("DBClusterIdentifier");
if let Some(var_413) = &input.db_cluster_identifier {
scope_412.string(var_413);
}
#[allow(unused_mut)]
let mut scope_414 = writer.prefix("TargetDBInstanceIdentifier");
if let Some(var_415) = &input.target_db_instance_identifier {
scope_414.string(var_415);
}
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_416 = writer.prefix("ResourceName");
if let Some(var_417) = &input.resource_name {
scope_416.string(var_417);
}
#[allow(unused_mut)]
let mut scope_418 = writer.prefix("Filters");
if let Some(var_419) = &input.filters {
let mut list_421 = scope_418.start_list(false, Some("Filter"));
for item_420 in var_419 {
#[allow(unused_mut)]
let mut entry_422 = list_421.entry();
crate::query_ser::serialize_structure_crate_model_filter(entry_422, item_420)?;
}
list_421.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_423 = writer.prefix("DBClusterIdentifier");
if let Some(var_424) = &input.db_cluster_identifier {
scope_423.string(var_424);
}
#[allow(unused_mut)]
let mut scope_425 = writer.prefix("NewDBClusterIdentifier");
if let Some(var_426) = &input.new_db_cluster_identifier {
scope_425.string(var_426);
}
#[allow(unused_mut)]
let mut scope_427 = writer.prefix("ApplyImmediately");
if input.apply_immediately {
scope_427.boolean(input.apply_immediately);
}
#[allow(unused_mut)]
let mut scope_428 = writer.prefix("BackupRetentionPeriod");
if let Some(var_429) = &input.backup_retention_period {
scope_428.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_429).into()),
);
}
#[allow(unused_mut)]
let mut scope_430 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_431) = &input.db_cluster_parameter_group_name {
scope_430.string(var_431);
}
#[allow(unused_mut)]
let mut scope_432 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_433) = &input.vpc_security_group_ids {
let mut list_435 = scope_432.start_list(false, Some("VpcSecurityGroupId"));
for item_434 in var_433 {
#[allow(unused_mut)]
let mut entry_436 = list_435.entry();
entry_436.string(item_434);
}
list_435.finish();
}
#[allow(unused_mut)]
let mut scope_437 = writer.prefix("Port");
if let Some(var_438) = &input.port {
scope_437.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_438).into()),
);
}
#[allow(unused_mut)]
let mut scope_439 = writer.prefix("MasterUserPassword");
if let Some(var_440) = &input.master_user_password {
scope_439.string(var_440);
}
#[allow(unused_mut)]
let mut scope_441 = writer.prefix("PreferredBackupWindow");
if let Some(var_442) = &input.preferred_backup_window {
scope_441.string(var_442);
}
#[allow(unused_mut)]
let mut scope_443 = writer.prefix("PreferredMaintenanceWindow");
if let Some(var_444) = &input.preferred_maintenance_window {
scope_443.string(var_444);
}
#[allow(unused_mut)]
let mut scope_445 = writer.prefix("CloudwatchLogsExportConfiguration");
if let Some(var_446) = &input.cloudwatch_logs_export_configuration {
crate::query_ser::serialize_structure_crate_model_cloudwatch_logs_export_configuration(
scope_445, var_446,
)?;
}
#[allow(unused_mut)]
let mut scope_447 = writer.prefix("EngineVersion");
if let Some(var_448) = &input.engine_version {
scope_447.string(var_448);
}
#[allow(unused_mut)]
let mut scope_449 = writer.prefix("DeletionProtection");
if let Some(var_450) = &input.deletion_protection {
scope_449.boolean(*var_450);
}
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_451 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_452) = &input.db_cluster_parameter_group_name {
scope_451.string(var_452);
}
#[allow(unused_mut)]
let mut scope_453 = writer.prefix("Parameters");
if let Some(var_454) = &input.parameters {
let mut list_456 = scope_453.start_list(false, Some("Parameter"));
for item_455 in var_454 {
#[allow(unused_mut)]
let mut entry_457 = list_456.entry();
crate::query_ser::serialize_structure_crate_model_parameter(entry_457, item_455)?;
}
list_456.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_458 = writer.prefix("DBClusterSnapshotIdentifier");
if let Some(var_459) = &input.db_cluster_snapshot_identifier {
scope_458.string(var_459);
}
#[allow(unused_mut)]
let mut scope_460 = writer.prefix("AttributeName");
if let Some(var_461) = &input.attribute_name {
scope_460.string(var_461);
}
#[allow(unused_mut)]
let mut scope_462 = writer.prefix("ValuesToAdd");
if let Some(var_463) = &input.values_to_add {
let mut list_465 = scope_462.start_list(false, Some("AttributeValue"));
for item_464 in var_463 {
#[allow(unused_mut)]
let mut entry_466 = list_465.entry();
entry_466.string(item_464);
}
list_465.finish();
}
#[allow(unused_mut)]
let mut scope_467 = writer.prefix("ValuesToRemove");
if let Some(var_468) = &input.values_to_remove {
let mut list_470 = scope_467.start_list(false, Some("AttributeValue"));
for item_469 in var_468 {
#[allow(unused_mut)]
let mut entry_471 = list_470.entry();
entry_471.string(item_469);
}
list_470.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_472 = writer.prefix("DBInstanceIdentifier");
if let Some(var_473) = &input.db_instance_identifier {
scope_472.string(var_473);
}
#[allow(unused_mut)]
let mut scope_474 = writer.prefix("DBInstanceClass");
if let Some(var_475) = &input.db_instance_class {
scope_474.string(var_475);
}
#[allow(unused_mut)]
let mut scope_476 = writer.prefix("ApplyImmediately");
if input.apply_immediately {
scope_476.boolean(input.apply_immediately);
}
#[allow(unused_mut)]
let mut scope_477 = writer.prefix("PreferredMaintenanceWindow");
if let Some(var_478) = &input.preferred_maintenance_window {
scope_477.string(var_478);
}
#[allow(unused_mut)]
let mut scope_479 = writer.prefix("AutoMinorVersionUpgrade");
if let Some(var_480) = &input.auto_minor_version_upgrade {
scope_479.boolean(*var_480);
}
#[allow(unused_mut)]
let mut scope_481 = writer.prefix("NewDBInstanceIdentifier");
if let Some(var_482) = &input.new_db_instance_identifier {
scope_481.string(var_482);
}
#[allow(unused_mut)]
let mut scope_483 = writer.prefix("CACertificateIdentifier");
if let Some(var_484) = &input.ca_certificate_identifier {
scope_483.string(var_484);
}
#[allow(unused_mut)]
let mut scope_485 = writer.prefix("CopyTagsToSnapshot");
if let Some(var_486) = &input.copy_tags_to_snapshot {
scope_485.boolean(*var_486);
}
#[allow(unused_mut)]
let mut scope_487 = writer.prefix("PromotionTier");
if let Some(var_488) = &input.promotion_tier {
scope_487.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_488).into()),
);
}
#[allow(unused_mut)]
let mut scope_489 = writer.prefix("EnablePerformanceInsights");
if let Some(var_490) = &input.enable_performance_insights {
scope_489.boolean(*var_490);
}
#[allow(unused_mut)]
let mut scope_491 = writer.prefix("PerformanceInsightsKMSKeyId");
if let Some(var_492) = &input.performance_insights_kms_key_id {
scope_491.string(var_492);
}
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_493 = writer.prefix("DBSubnetGroupName");
if let Some(var_494) = &input.db_subnet_group_name {
scope_493.string(var_494);
}
#[allow(unused_mut)]
let mut scope_495 = writer.prefix("DBSubnetGroupDescription");
if let Some(var_496) = &input.db_subnet_group_description {
scope_495.string(var_496);
}
#[allow(unused_mut)]
let mut scope_497 = writer.prefix("SubnetIds");
if let Some(var_498) = &input.subnet_ids {
let mut list_500 = scope_497.start_list(false, Some("SubnetIdentifier"));
for item_499 in var_498 {
#[allow(unused_mut)]
let mut entry_501 = list_500.entry();
entry_501.string(item_499);
}
list_500.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_502 = writer.prefix("SubscriptionName");
if let Some(var_503) = &input.subscription_name {
scope_502.string(var_503);
}
#[allow(unused_mut)]
let mut scope_504 = writer.prefix("SnsTopicArn");
if let Some(var_505) = &input.sns_topic_arn {
scope_504.string(var_505);
}
#[allow(unused_mut)]
let mut scope_506 = writer.prefix("SourceType");
if let Some(var_507) = &input.source_type {
scope_506.string(var_507);
}
#[allow(unused_mut)]
let mut scope_508 = writer.prefix("EventCategories");
if let Some(var_509) = &input.event_categories {
let mut list_511 = scope_508.start_list(false, Some("EventCategory"));
for item_510 in var_509 {
#[allow(unused_mut)]
let mut entry_512 = list_511.entry();
entry_512.string(item_510);
}
list_511.finish();
}
#[allow(unused_mut)]
let mut scope_513 = writer.prefix("Enabled");
if let Some(var_514) = &input.enabled {
scope_513.boolean(*var_514);
}
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_515 = writer.prefix("GlobalClusterIdentifier");
if let Some(var_516) = &input.global_cluster_identifier {
scope_515.string(var_516);
}
#[allow(unused_mut)]
let mut scope_517 = writer.prefix("NewGlobalClusterIdentifier");
if let Some(var_518) = &input.new_global_cluster_identifier {
scope_517.string(var_518);
}
#[allow(unused_mut)]
let mut scope_519 = writer.prefix("DeletionProtection");
if let Some(var_520) = &input.deletion_protection {
scope_519.boolean(*var_520);
}
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_521 = writer.prefix("DBInstanceIdentifier");
if let Some(var_522) = &input.db_instance_identifier {
scope_521.string(var_522);
}
#[allow(unused_mut)]
let mut scope_523 = writer.prefix("ForceFailover");
if let Some(var_524) = &input.force_failover {
scope_523.boolean(*var_524);
}
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_525 = writer.prefix("GlobalClusterIdentifier");
if let Some(var_526) = &input.global_cluster_identifier {
scope_525.string(var_526);
}
#[allow(unused_mut)]
let mut scope_527 = writer.prefix("DbClusterIdentifier");
if let Some(var_528) = &input.db_cluster_identifier {
scope_527.string(var_528);
}
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_529 = writer.prefix("SubscriptionName");
if let Some(var_530) = &input.subscription_name {
scope_529.string(var_530);
}
#[allow(unused_mut)]
let mut scope_531 = writer.prefix("SourceIdentifier");
if let Some(var_532) = &input.source_identifier {
scope_531.string(var_532);
}
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_533 = writer.prefix("ResourceName");
if let Some(var_534) = &input.resource_name {
scope_533.string(var_534);
}
#[allow(unused_mut)]
let mut scope_535 = writer.prefix("TagKeys");
if let Some(var_536) = &input.tag_keys {
let mut list_538 = scope_535.start_list(false, None);
for item_537 in var_536 {
#[allow(unused_mut)]
let mut entry_539 = list_538.entry();
entry_539.string(item_537);
}
list_538.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_540 = writer.prefix("DBClusterParameterGroupName");
if let Some(var_541) = &input.db_cluster_parameter_group_name {
scope_540.string(var_541);
}
#[allow(unused_mut)]
let mut scope_542 = writer.prefix("ResetAllParameters");
if input.reset_all_parameters {
scope_542.boolean(input.reset_all_parameters);
}
#[allow(unused_mut)]
let mut scope_543 = writer.prefix("Parameters");
if let Some(var_544) = &input.parameters {
let mut list_546 = scope_543.start_list(false, Some("Parameter"));
for item_545 in var_544 {
#[allow(unused_mut)]
let mut entry_547 = list_546.entry();
crate::query_ser::serialize_structure_crate_model_parameter(entry_547, item_545)?;
}
list_546.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_548 = writer.prefix("AvailabilityZones");
if let Some(var_549) = &input.availability_zones {
let mut list_551 = scope_548.start_list(false, Some("AvailabilityZone"));
for item_550 in var_549 {
#[allow(unused_mut)]
let mut entry_552 = list_551.entry();
entry_552.string(item_550);
}
list_551.finish();
}
#[allow(unused_mut)]
let mut scope_553 = writer.prefix("DBClusterIdentifier");
if let Some(var_554) = &input.db_cluster_identifier {
scope_553.string(var_554);
}
#[allow(unused_mut)]
let mut scope_555 = writer.prefix("SnapshotIdentifier");
if let Some(var_556) = &input.snapshot_identifier {
scope_555.string(var_556);
}
#[allow(unused_mut)]
let mut scope_557 = writer.prefix("Engine");
if let Some(var_558) = &input.engine {
scope_557.string(var_558);
}
#[allow(unused_mut)]
let mut scope_559 = writer.prefix("EngineVersion");
if let Some(var_560) = &input.engine_version {
scope_559.string(var_560);
}
#[allow(unused_mut)]
let mut scope_561 = writer.prefix("Port");
if let Some(var_562) = &input.port {
scope_561.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_562).into()),
);
}
#[allow(unused_mut)]
let mut scope_563 = writer.prefix("DBSubnetGroupName");
if let Some(var_564) = &input.db_subnet_group_name {
scope_563.string(var_564);
}
#[allow(unused_mut)]
let mut scope_565 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_566) = &input.vpc_security_group_ids {
let mut list_568 = scope_565.start_list(false, Some("VpcSecurityGroupId"));
for item_567 in var_566 {
#[allow(unused_mut)]
let mut entry_569 = list_568.entry();
entry_569.string(item_567);
}
list_568.finish();
}
#[allow(unused_mut)]
let mut scope_570 = writer.prefix("Tags");
if let Some(var_571) = &input.tags {
let mut list_573 = scope_570.start_list(false, Some("Tag"));
for item_572 in var_571 {
#[allow(unused_mut)]
let mut entry_574 = list_573.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_574, item_572)?;
}
list_573.finish();
}
#[allow(unused_mut)]
let mut scope_575 = writer.prefix("KmsKeyId");
if let Some(var_576) = &input.kms_key_id {
scope_575.string(var_576);
}
#[allow(unused_mut)]
let mut scope_577 = writer.prefix("EnableCloudwatchLogsExports");
if let Some(var_578) = &input.enable_cloudwatch_logs_exports {
let mut list_580 = scope_577.start_list(false, None);
for item_579 in var_578 {
#[allow(unused_mut)]
let mut entry_581 = list_580.entry();
entry_581.string(item_579);
}
list_580.finish();
}
#[allow(unused_mut)]
let mut scope_582 = writer.prefix("DeletionProtection");
if let Some(var_583) = &input.deletion_protection {
scope_582.boolean(*var_583);
}
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_584 = writer.prefix("DBClusterIdentifier");
if let Some(var_585) = &input.db_cluster_identifier {
scope_584.string(var_585);
}
#[allow(unused_mut)]
let mut scope_586 = writer.prefix("RestoreType");
if let Some(var_587) = &input.restore_type {
scope_586.string(var_587);
}
#[allow(unused_mut)]
let mut scope_588 = writer.prefix("SourceDBClusterIdentifier");
if let Some(var_589) = &input.source_db_cluster_identifier {
scope_588.string(var_589);
}
#[allow(unused_mut)]
let mut scope_590 = writer.prefix("RestoreToTime");
if let Some(var_591) = &input.restore_to_time {
scope_590.date_time(var_591, aws_smithy_types::date_time::Format::DateTime)?;
}
#[allow(unused_mut)]
let mut scope_592 = writer.prefix("UseLatestRestorableTime");
if input.use_latest_restorable_time {
scope_592.boolean(input.use_latest_restorable_time);
}
#[allow(unused_mut)]
let mut scope_593 = writer.prefix("Port");
if let Some(var_594) = &input.port {
scope_593.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_594).into()),
);
}
#[allow(unused_mut)]
let mut scope_595 = writer.prefix("DBSubnetGroupName");
if let Some(var_596) = &input.db_subnet_group_name {
scope_595.string(var_596);
}
#[allow(unused_mut)]
let mut scope_597 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_598) = &input.vpc_security_group_ids {
let mut list_600 = scope_597.start_list(false, Some("VpcSecurityGroupId"));
for item_599 in var_598 {
#[allow(unused_mut)]
let mut entry_601 = list_600.entry();
entry_601.string(item_599);
}
list_600.finish();
}
#[allow(unused_mut)]
let mut scope_602 = writer.prefix("Tags");
if let Some(var_603) = &input.tags {
let mut list_605 = scope_602.start_list(false, Some("Tag"));
for item_604 in var_603 {
#[allow(unused_mut)]
let mut entry_606 = list_605.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_606, item_604)?;
}
list_605.finish();
}
#[allow(unused_mut)]
let mut scope_607 = writer.prefix("KmsKeyId");
if let Some(var_608) = &input.kms_key_id {
scope_607.string(var_608);
}
#[allow(unused_mut)]
let mut scope_609 = writer.prefix("EnableCloudwatchLogsExports");
if let Some(var_610) = &input.enable_cloudwatch_logs_exports {
let mut list_612 = scope_609.start_list(false, None);
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("DeletionProtection");
if let Some(var_615) = &input.deletion_protection {
scope_614.boolean(*var_615);
}
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_616 = writer.prefix("DBClusterIdentifier");
if let Some(var_617) = &input.db_cluster_identifier {
scope_616.string(var_617);
}
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_618 = writer.prefix("DBClusterIdentifier");
if let Some(var_619) = &input.db_cluster_identifier {
scope_618.string(var_619);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}