pub fn serialize_operation_crate_operation_accept_reserved_node_exchange(
input: &crate::input::AcceptReservedNodeExchangeInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AcceptReservedNodeExchange", "2012-12-01");
#[allow(unused_mut)]
let mut scope_1 = writer.prefix("ReservedNodeId");
if let Some(var_2) = &input.reserved_node_id {
scope_1.string(var_2);
}
#[allow(unused_mut)]
let mut scope_3 = writer.prefix("TargetReservedNodeOfferingId");
if let Some(var_4) = &input.target_reserved_node_offering_id {
scope_3.string(var_4);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_add_partner(
input: &crate::input::AddPartnerInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "AddPartner", "2012-12-01");
#[allow(unused_mut)]
let mut scope_5 = writer.prefix("AccountId");
if let Some(var_6) = &input.account_id {
scope_5.string(var_6);
}
#[allow(unused_mut)]
let mut scope_7 = writer.prefix("ClusterIdentifier");
if let Some(var_8) = &input.cluster_identifier {
scope_7.string(var_8);
}
#[allow(unused_mut)]
let mut scope_9 = writer.prefix("DatabaseName");
if let Some(var_10) = &input.database_name {
scope_9.string(var_10);
}
#[allow(unused_mut)]
let mut scope_11 = writer.prefix("PartnerName");
if let Some(var_12) = &input.partner_name {
scope_11.string(var_12);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_associate_data_share_consumer(
input: &crate::input::AssociateDataShareConsumerInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AssociateDataShareConsumer", "2012-12-01");
#[allow(unused_mut)]
let mut scope_13 = writer.prefix("DataShareArn");
if let Some(var_14) = &input.data_share_arn {
scope_13.string(var_14);
}
#[allow(unused_mut)]
let mut scope_15 = writer.prefix("AssociateEntireAccount");
if let Some(var_16) = &input.associate_entire_account {
scope_15.boolean(*var_16);
}
#[allow(unused_mut)]
let mut scope_17 = writer.prefix("ConsumerArn");
if let Some(var_18) = &input.consumer_arn {
scope_17.string(var_18);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_authorize_cluster_security_group_ingress(
input: &crate::input::AuthorizeClusterSecurityGroupIngressInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"AuthorizeClusterSecurityGroupIngress",
"2012-12-01",
);
#[allow(unused_mut)]
let mut scope_19 = writer.prefix("ClusterSecurityGroupName");
if let Some(var_20) = &input.cluster_security_group_name {
scope_19.string(var_20);
}
#[allow(unused_mut)]
let mut scope_21 = writer.prefix("CIDRIP");
if let Some(var_22) = &input.cidrip {
scope_21.string(var_22);
}
#[allow(unused_mut)]
let mut scope_23 = writer.prefix("EC2SecurityGroupName");
if let Some(var_24) = &input.ec2_security_group_name {
scope_23.string(var_24);
}
#[allow(unused_mut)]
let mut scope_25 = writer.prefix("EC2SecurityGroupOwnerId");
if let Some(var_26) = &input.ec2_security_group_owner_id {
scope_25.string(var_26);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_authorize_data_share(
input: &crate::input::AuthorizeDataShareInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AuthorizeDataShare", "2012-12-01");
#[allow(unused_mut)]
let mut scope_27 = writer.prefix("DataShareArn");
if let Some(var_28) = &input.data_share_arn {
scope_27.string(var_28);
}
#[allow(unused_mut)]
let mut scope_29 = writer.prefix("ConsumerIdentifier");
if let Some(var_30) = &input.consumer_identifier {
scope_29.string(var_30);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_authorize_endpoint_access(
input: &crate::input::AuthorizeEndpointAccessInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AuthorizeEndpointAccess", "2012-12-01");
#[allow(unused_mut)]
let mut scope_31 = writer.prefix("ClusterIdentifier");
if let Some(var_32) = &input.cluster_identifier {
scope_31.string(var_32);
}
#[allow(unused_mut)]
let mut scope_33 = writer.prefix("Account");
if let Some(var_34) = &input.account {
scope_33.string(var_34);
}
#[allow(unused_mut)]
let mut scope_35 = writer.prefix("VpcIds");
if let Some(var_36) = &input.vpc_ids {
let mut list_38 = scope_35.start_list(false, Some("VpcIdentifier"));
for item_37 in var_36 {
#[allow(unused_mut)]
let mut entry_39 = list_38.entry();
entry_39.string(item_37);
}
list_38.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_authorize_snapshot_access(
input: &crate::input::AuthorizeSnapshotAccessInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "AuthorizeSnapshotAccess", "2012-12-01");
#[allow(unused_mut)]
let mut scope_40 = writer.prefix("SnapshotIdentifier");
if let Some(var_41) = &input.snapshot_identifier {
scope_40.string(var_41);
}
#[allow(unused_mut)]
let mut scope_42 = writer.prefix("SnapshotClusterIdentifier");
if let Some(var_43) = &input.snapshot_cluster_identifier {
scope_42.string(var_43);
}
#[allow(unused_mut)]
let mut scope_44 = writer.prefix("AccountWithRestoreAccess");
if let Some(var_45) = &input.account_with_restore_access {
scope_44.string(var_45);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_batch_delete_cluster_snapshots(
input: &crate::input::BatchDeleteClusterSnapshotsInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "BatchDeleteClusterSnapshots", "2012-12-01");
#[allow(unused_mut)]
let mut scope_46 = writer.prefix("Identifiers");
if let Some(var_47) = &input.identifiers {
let mut list_49 = scope_46.start_list(false, Some("DeleteClusterSnapshotMessage"));
for item_48 in var_47 {
#[allow(unused_mut)]
let mut entry_50 = list_49.entry();
crate::query_ser::serialize_structure_crate_model_delete_cluster_snapshot_message(
entry_50, item_48,
);
}
list_49.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_batch_modify_cluster_snapshots(
input: &crate::input::BatchModifyClusterSnapshotsInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "BatchModifyClusterSnapshots", "2012-12-01");
#[allow(unused_mut)]
let mut scope_51 = writer.prefix("SnapshotIdentifierList");
if let Some(var_52) = &input.snapshot_identifier_list {
let mut list_54 = scope_51.start_list(false, Some("String"));
for item_53 in var_52 {
#[allow(unused_mut)]
let mut entry_55 = list_54.entry();
entry_55.string(item_53);
}
list_54.finish();
}
#[allow(unused_mut)]
let mut scope_56 = writer.prefix("ManualSnapshotRetentionPeriod");
if let Some(var_57) = &input.manual_snapshot_retention_period {
scope_56.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_57).into()),
);
}
#[allow(unused_mut)]
let mut scope_58 = writer.prefix("Force");
if input.force {
scope_58.boolean(input.force);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_cancel_resize(
input: &crate::input::CancelResizeInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CancelResize", "2012-12-01");
#[allow(unused_mut)]
let mut scope_59 = writer.prefix("ClusterIdentifier");
if let Some(var_60) = &input.cluster_identifier {
scope_59.string(var_60);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_copy_cluster_snapshot(
input: &crate::input::CopyClusterSnapshotInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CopyClusterSnapshot", "2012-12-01");
#[allow(unused_mut)]
let mut scope_61 = writer.prefix("SourceSnapshotIdentifier");
if let Some(var_62) = &input.source_snapshot_identifier {
scope_61.string(var_62);
}
#[allow(unused_mut)]
let mut scope_63 = writer.prefix("SourceSnapshotClusterIdentifier");
if let Some(var_64) = &input.source_snapshot_cluster_identifier {
scope_63.string(var_64);
}
#[allow(unused_mut)]
let mut scope_65 = writer.prefix("TargetSnapshotIdentifier");
if let Some(var_66) = &input.target_snapshot_identifier {
scope_65.string(var_66);
}
#[allow(unused_mut)]
let mut scope_67 = writer.prefix("ManualSnapshotRetentionPeriod");
if let Some(var_68) = &input.manual_snapshot_retention_period {
scope_67.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_68).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_authentication_profile(
input: &crate::input::CreateAuthenticationProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateAuthenticationProfile", "2012-12-01");
#[allow(unused_mut)]
let mut scope_69 = writer.prefix("AuthenticationProfileName");
if let Some(var_70) = &input.authentication_profile_name {
scope_69.string(var_70);
}
#[allow(unused_mut)]
let mut scope_71 = writer.prefix("AuthenticationProfileContent");
if let Some(var_72) = &input.authentication_profile_content {
scope_71.string(var_72);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_cluster(
input: &crate::input::CreateClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateCluster", "2012-12-01");
#[allow(unused_mut)]
let mut scope_73 = writer.prefix("DBName");
if let Some(var_74) = &input.db_name {
scope_73.string(var_74);
}
#[allow(unused_mut)]
let mut scope_75 = writer.prefix("ClusterIdentifier");
if let Some(var_76) = &input.cluster_identifier {
scope_75.string(var_76);
}
#[allow(unused_mut)]
let mut scope_77 = writer.prefix("ClusterType");
if let Some(var_78) = &input.cluster_type {
scope_77.string(var_78);
}
#[allow(unused_mut)]
let mut scope_79 = writer.prefix("NodeType");
if let Some(var_80) = &input.node_type {
scope_79.string(var_80);
}
#[allow(unused_mut)]
let mut scope_81 = writer.prefix("MasterUsername");
if let Some(var_82) = &input.master_username {
scope_81.string(var_82);
}
#[allow(unused_mut)]
let mut scope_83 = writer.prefix("MasterUserPassword");
if let Some(var_84) = &input.master_user_password {
scope_83.string(var_84);
}
#[allow(unused_mut)]
let mut scope_85 = writer.prefix("ClusterSecurityGroups");
if let Some(var_86) = &input.cluster_security_groups {
let mut list_88 = scope_85.start_list(false, Some("ClusterSecurityGroupName"));
for item_87 in var_86 {
#[allow(unused_mut)]
let mut entry_89 = list_88.entry();
entry_89.string(item_87);
}
list_88.finish();
}
#[allow(unused_mut)]
let mut scope_90 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_91) = &input.vpc_security_group_ids {
let mut list_93 = scope_90.start_list(false, Some("VpcSecurityGroupId"));
for item_92 in var_91 {
#[allow(unused_mut)]
let mut entry_94 = list_93.entry();
entry_94.string(item_92);
}
list_93.finish();
}
#[allow(unused_mut)]
let mut scope_95 = writer.prefix("ClusterSubnetGroupName");
if let Some(var_96) = &input.cluster_subnet_group_name {
scope_95.string(var_96);
}
#[allow(unused_mut)]
let mut scope_97 = writer.prefix("AvailabilityZone");
if let Some(var_98) = &input.availability_zone {
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("ClusterParameterGroupName");
if let Some(var_102) = &input.cluster_parameter_group_name {
scope_101.string(var_102);
}
#[allow(unused_mut)]
let mut scope_103 = writer.prefix("AutomatedSnapshotRetentionPeriod");
if let Some(var_104) = &input.automated_snapshot_retention_period {
scope_103.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_104).into()),
);
}
#[allow(unused_mut)]
let mut scope_105 = writer.prefix("ManualSnapshotRetentionPeriod");
if let Some(var_106) = &input.manual_snapshot_retention_period {
scope_105.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_106).into()),
);
}
#[allow(unused_mut)]
let mut scope_107 = writer.prefix("Port");
if let Some(var_108) = &input.port {
scope_107.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_108).into()),
);
}
#[allow(unused_mut)]
let mut scope_109 = writer.prefix("ClusterVersion");
if let Some(var_110) = &input.cluster_version {
scope_109.string(var_110);
}
#[allow(unused_mut)]
let mut scope_111 = writer.prefix("AllowVersionUpgrade");
if let Some(var_112) = &input.allow_version_upgrade {
scope_111.boolean(*var_112);
}
#[allow(unused_mut)]
let mut scope_113 = writer.prefix("NumberOfNodes");
if let Some(var_114) = &input.number_of_nodes {
scope_113.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_114).into()),
);
}
#[allow(unused_mut)]
let mut scope_115 = writer.prefix("PubliclyAccessible");
if let Some(var_116) = &input.publicly_accessible {
scope_115.boolean(*var_116);
}
#[allow(unused_mut)]
let mut scope_117 = writer.prefix("Encrypted");
if let Some(var_118) = &input.encrypted {
scope_117.boolean(*var_118);
}
#[allow(unused_mut)]
let mut scope_119 = writer.prefix("HsmClientCertificateIdentifier");
if let Some(var_120) = &input.hsm_client_certificate_identifier {
scope_119.string(var_120);
}
#[allow(unused_mut)]
let mut scope_121 = writer.prefix("HsmConfigurationIdentifier");
if let Some(var_122) = &input.hsm_configuration_identifier {
scope_121.string(var_122);
}
#[allow(unused_mut)]
let mut scope_123 = writer.prefix("ElasticIp");
if let Some(var_124) = &input.elastic_ip {
scope_123.string(var_124);
}
#[allow(unused_mut)]
let mut scope_125 = writer.prefix("Tags");
if let Some(var_126) = &input.tags {
let mut list_128 = scope_125.start_list(false, Some("Tag"));
for item_127 in var_126 {
#[allow(unused_mut)]
let mut entry_129 = list_128.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_129, item_127);
}
list_128.finish();
}
#[allow(unused_mut)]
let mut scope_130 = writer.prefix("KmsKeyId");
if let Some(var_131) = &input.kms_key_id {
scope_130.string(var_131);
}
#[allow(unused_mut)]
let mut scope_132 = writer.prefix("EnhancedVpcRouting");
if let Some(var_133) = &input.enhanced_vpc_routing {
scope_132.boolean(*var_133);
}
#[allow(unused_mut)]
let mut scope_134 = writer.prefix("AdditionalInfo");
if let Some(var_135) = &input.additional_info {
scope_134.string(var_135);
}
#[allow(unused_mut)]
let mut scope_136 = writer.prefix("IamRoles");
if let Some(var_137) = &input.iam_roles {
let mut list_139 = scope_136.start_list(false, Some("IamRoleArn"));
for item_138 in var_137 {
#[allow(unused_mut)]
let mut entry_140 = list_139.entry();
entry_140.string(item_138);
}
list_139.finish();
}
#[allow(unused_mut)]
let mut scope_141 = writer.prefix("MaintenanceTrackName");
if let Some(var_142) = &input.maintenance_track_name {
scope_141.string(var_142);
}
#[allow(unused_mut)]
let mut scope_143 = writer.prefix("SnapshotScheduleIdentifier");
if let Some(var_144) = &input.snapshot_schedule_identifier {
scope_143.string(var_144);
}
#[allow(unused_mut)]
let mut scope_145 = writer.prefix("AvailabilityZoneRelocation");
if let Some(var_146) = &input.availability_zone_relocation {
scope_145.boolean(*var_146);
}
#[allow(unused_mut)]
let mut scope_147 = writer.prefix("AquaConfigurationStatus");
if let Some(var_148) = &input.aqua_configuration_status {
scope_147.string(var_148.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_cluster_parameter_group(
input: &crate::input::CreateClusterParameterGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateClusterParameterGroup", "2012-12-01");
#[allow(unused_mut)]
let mut scope_149 = writer.prefix("ParameterGroupName");
if let Some(var_150) = &input.parameter_group_name {
scope_149.string(var_150);
}
#[allow(unused_mut)]
let mut scope_151 = writer.prefix("ParameterGroupFamily");
if let Some(var_152) = &input.parameter_group_family {
scope_151.string(var_152);
}
#[allow(unused_mut)]
let mut scope_153 = writer.prefix("Description");
if let Some(var_154) = &input.description {
scope_153.string(var_154);
}
#[allow(unused_mut)]
let mut scope_155 = writer.prefix("Tags");
if let Some(var_156) = &input.tags {
let mut list_158 = scope_155.start_list(false, Some("Tag"));
for item_157 in var_156 {
#[allow(unused_mut)]
let mut entry_159 = list_158.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_159, item_157);
}
list_158.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_cluster_security_group(
input: &crate::input::CreateClusterSecurityGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateClusterSecurityGroup", "2012-12-01");
#[allow(unused_mut)]
let mut scope_160 = writer.prefix("ClusterSecurityGroupName");
if let Some(var_161) = &input.cluster_security_group_name {
scope_160.string(var_161);
}
#[allow(unused_mut)]
let mut scope_162 = writer.prefix("Description");
if let Some(var_163) = &input.description {
scope_162.string(var_163);
}
#[allow(unused_mut)]
let mut scope_164 = writer.prefix("Tags");
if let Some(var_165) = &input.tags {
let mut list_167 = scope_164.start_list(false, Some("Tag"));
for item_166 in var_165 {
#[allow(unused_mut)]
let mut entry_168 = list_167.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_168, item_166);
}
list_167.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_cluster_snapshot(
input: &crate::input::CreateClusterSnapshotInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateClusterSnapshot", "2012-12-01");
#[allow(unused_mut)]
let mut scope_169 = writer.prefix("SnapshotIdentifier");
if let Some(var_170) = &input.snapshot_identifier {
scope_169.string(var_170);
}
#[allow(unused_mut)]
let mut scope_171 = writer.prefix("ClusterIdentifier");
if let Some(var_172) = &input.cluster_identifier {
scope_171.string(var_172);
}
#[allow(unused_mut)]
let mut scope_173 = writer.prefix("ManualSnapshotRetentionPeriod");
if let Some(var_174) = &input.manual_snapshot_retention_period {
scope_173.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_174).into()),
);
}
#[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_cluster_subnet_group(
input: &crate::input::CreateClusterSubnetGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateClusterSubnetGroup", "2012-12-01");
#[allow(unused_mut)]
let mut scope_180 = writer.prefix("ClusterSubnetGroupName");
if let Some(var_181) = &input.cluster_subnet_group_name {
scope_180.string(var_181);
}
#[allow(unused_mut)]
let mut scope_182 = writer.prefix("Description");
if let Some(var_183) = &input.description {
scope_182.string(var_183);
}
#[allow(unused_mut)]
let mut scope_184 = writer.prefix("SubnetIds");
if let Some(var_185) = &input.subnet_ids {
let mut list_187 = scope_184.start_list(false, Some("SubnetIdentifier"));
for item_186 in var_185 {
#[allow(unused_mut)]
let mut entry_188 = list_187.entry();
entry_188.string(item_186);
}
list_187.finish();
}
#[allow(unused_mut)]
let mut scope_189 = writer.prefix("Tags");
if let Some(var_190) = &input.tags {
let mut list_192 = scope_189.start_list(false, Some("Tag"));
for item_191 in var_190 {
#[allow(unused_mut)]
let mut entry_193 = list_192.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_193, item_191);
}
list_192.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_endpoint_access(
input: &crate::input::CreateEndpointAccessInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateEndpointAccess", "2012-12-01");
#[allow(unused_mut)]
let mut scope_194 = writer.prefix("ClusterIdentifier");
if let Some(var_195) = &input.cluster_identifier {
scope_194.string(var_195);
}
#[allow(unused_mut)]
let mut scope_196 = writer.prefix("ResourceOwner");
if let Some(var_197) = &input.resource_owner {
scope_196.string(var_197);
}
#[allow(unused_mut)]
let mut scope_198 = writer.prefix("EndpointName");
if let Some(var_199) = &input.endpoint_name {
scope_198.string(var_199);
}
#[allow(unused_mut)]
let mut scope_200 = writer.prefix("SubnetGroupName");
if let Some(var_201) = &input.subnet_group_name {
scope_200.string(var_201);
}
#[allow(unused_mut)]
let mut scope_202 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_203) = &input.vpc_security_group_ids {
let mut list_205 = scope_202.start_list(false, Some("VpcSecurityGroupId"));
for item_204 in var_203 {
#[allow(unused_mut)]
let mut entry_206 = list_205.entry();
entry_206.string(item_204);
}
list_205.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, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateEventSubscription", "2012-12-01");
#[allow(unused_mut)]
let mut scope_207 = writer.prefix("SubscriptionName");
if let Some(var_208) = &input.subscription_name {
scope_207.string(var_208);
}
#[allow(unused_mut)]
let mut scope_209 = writer.prefix("SnsTopicArn");
if let Some(var_210) = &input.sns_topic_arn {
scope_209.string(var_210);
}
#[allow(unused_mut)]
let mut scope_211 = writer.prefix("SourceType");
if let Some(var_212) = &input.source_type {
scope_211.string(var_212);
}
#[allow(unused_mut)]
let mut scope_213 = writer.prefix("SourceIds");
if let Some(var_214) = &input.source_ids {
let mut list_216 = scope_213.start_list(false, Some("SourceId"));
for item_215 in var_214 {
#[allow(unused_mut)]
let mut entry_217 = list_216.entry();
entry_217.string(item_215);
}
list_216.finish();
}
#[allow(unused_mut)]
let mut scope_218 = writer.prefix("EventCategories");
if let Some(var_219) = &input.event_categories {
let mut list_221 = scope_218.start_list(false, Some("EventCategory"));
for item_220 in var_219 {
#[allow(unused_mut)]
let mut entry_222 = list_221.entry();
entry_222.string(item_220);
}
list_221.finish();
}
#[allow(unused_mut)]
let mut scope_223 = writer.prefix("Severity");
if let Some(var_224) = &input.severity {
scope_223.string(var_224);
}
#[allow(unused_mut)]
let mut scope_225 = writer.prefix("Enabled");
if let Some(var_226) = &input.enabled {
scope_225.boolean(*var_226);
}
#[allow(unused_mut)]
let mut scope_227 = writer.prefix("Tags");
if let Some(var_228) = &input.tags {
let mut list_230 = scope_227.start_list(false, Some("Tag"));
for item_229 in var_228 {
#[allow(unused_mut)]
let mut entry_231 = list_230.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_231, item_229);
}
list_230.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_hsm_client_certificate(
input: &crate::input::CreateHsmClientCertificateInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateHsmClientCertificate", "2012-12-01");
#[allow(unused_mut)]
let mut scope_232 = writer.prefix("HsmClientCertificateIdentifier");
if let Some(var_233) = &input.hsm_client_certificate_identifier {
scope_232.string(var_233);
}
#[allow(unused_mut)]
let mut scope_234 = writer.prefix("Tags");
if let Some(var_235) = &input.tags {
let mut list_237 = scope_234.start_list(false, Some("Tag"));
for item_236 in var_235 {
#[allow(unused_mut)]
let mut entry_238 = list_237.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_238, item_236);
}
list_237.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_hsm_configuration(
input: &crate::input::CreateHsmConfigurationInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateHsmConfiguration", "2012-12-01");
#[allow(unused_mut)]
let mut scope_239 = writer.prefix("HsmConfigurationIdentifier");
if let Some(var_240) = &input.hsm_configuration_identifier {
scope_239.string(var_240);
}
#[allow(unused_mut)]
let mut scope_241 = writer.prefix("Description");
if let Some(var_242) = &input.description {
scope_241.string(var_242);
}
#[allow(unused_mut)]
let mut scope_243 = writer.prefix("HsmIpAddress");
if let Some(var_244) = &input.hsm_ip_address {
scope_243.string(var_244);
}
#[allow(unused_mut)]
let mut scope_245 = writer.prefix("HsmPartitionName");
if let Some(var_246) = &input.hsm_partition_name {
scope_245.string(var_246);
}
#[allow(unused_mut)]
let mut scope_247 = writer.prefix("HsmPartitionPassword");
if let Some(var_248) = &input.hsm_partition_password {
scope_247.string(var_248);
}
#[allow(unused_mut)]
let mut scope_249 = writer.prefix("HsmServerPublicCertificate");
if let Some(var_250) = &input.hsm_server_public_certificate {
scope_249.string(var_250);
}
#[allow(unused_mut)]
let mut scope_251 = writer.prefix("Tags");
if let Some(var_252) = &input.tags {
let mut list_254 = scope_251.start_list(false, Some("Tag"));
for item_253 in var_252 {
#[allow(unused_mut)]
let mut entry_255 = list_254.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_255, item_253);
}
list_254.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_scheduled_action(
input: &crate::input::CreateScheduledActionInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateScheduledAction", "2012-12-01");
#[allow(unused_mut)]
let mut scope_256 = writer.prefix("ScheduledActionName");
if let Some(var_257) = &input.scheduled_action_name {
scope_256.string(var_257);
}
#[allow(unused_mut)]
let mut scope_258 = writer.prefix("TargetAction");
if let Some(var_259) = &input.target_action {
crate::query_ser::serialize_structure_crate_model_scheduled_action_type(scope_258, var_259);
}
#[allow(unused_mut)]
let mut scope_260 = writer.prefix("Schedule");
if let Some(var_261) = &input.schedule {
scope_260.string(var_261);
}
#[allow(unused_mut)]
let mut scope_262 = writer.prefix("IamRole");
if let Some(var_263) = &input.iam_role {
scope_262.string(var_263);
}
#[allow(unused_mut)]
let mut scope_264 = writer.prefix("ScheduledActionDescription");
if let Some(var_265) = &input.scheduled_action_description {
scope_264.string(var_265);
}
#[allow(unused_mut)]
let mut scope_266 = writer.prefix("StartTime");
if let Some(var_267) = &input.start_time {
scope_266.instant(var_267, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_268 = writer.prefix("EndTime");
if let Some(var_269) = &input.end_time {
scope_268.instant(var_269, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_270 = writer.prefix("Enable");
if let Some(var_271) = &input.enable {
scope_270.boolean(*var_271);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_snapshot_copy_grant(
input: &crate::input::CreateSnapshotCopyGrantInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateSnapshotCopyGrant", "2012-12-01");
#[allow(unused_mut)]
let mut scope_272 = writer.prefix("SnapshotCopyGrantName");
if let Some(var_273) = &input.snapshot_copy_grant_name {
scope_272.string(var_273);
}
#[allow(unused_mut)]
let mut scope_274 = writer.prefix("KmsKeyId");
if let Some(var_275) = &input.kms_key_id {
scope_274.string(var_275);
}
#[allow(unused_mut)]
let mut scope_276 = writer.prefix("Tags");
if let Some(var_277) = &input.tags {
let mut list_279 = scope_276.start_list(false, Some("Tag"));
for item_278 in var_277 {
#[allow(unused_mut)]
let mut entry_280 = list_279.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_280, item_278);
}
list_279.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_snapshot_schedule(
input: &crate::input::CreateSnapshotScheduleInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "CreateSnapshotSchedule", "2012-12-01");
#[allow(unused_mut)]
let mut scope_281 = writer.prefix("ScheduleDefinitions");
if let Some(var_282) = &input.schedule_definitions {
let mut list_284 = scope_281.start_list(false, Some("ScheduleDefinition"));
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("ScheduleIdentifier");
if let Some(var_287) = &input.schedule_identifier {
scope_286.string(var_287);
}
#[allow(unused_mut)]
let mut scope_288 = writer.prefix("ScheduleDescription");
if let Some(var_289) = &input.schedule_description {
scope_288.string(var_289);
}
#[allow(unused_mut)]
let mut scope_290 = writer.prefix("Tags");
if let Some(var_291) = &input.tags {
let mut list_293 = scope_290.start_list(false, Some("Tag"));
for item_292 in var_291 {
#[allow(unused_mut)]
let mut entry_294 = list_293.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_294, item_292);
}
list_293.finish();
}
#[allow(unused_mut)]
let mut scope_295 = writer.prefix("DryRun");
if let Some(var_296) = &input.dry_run {
scope_295.boolean(*var_296);
}
#[allow(unused_mut)]
let mut scope_297 = writer.prefix("NextInvocations");
if let Some(var_298) = &input.next_invocations {
scope_297.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_298).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_tags(
input: &crate::input::CreateTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateTags", "2012-12-01");
#[allow(unused_mut)]
let mut scope_299 = writer.prefix("ResourceName");
if let Some(var_300) = &input.resource_name {
scope_299.string(var_300);
}
#[allow(unused_mut)]
let mut scope_301 = writer.prefix("Tags");
if let Some(var_302) = &input.tags {
let mut list_304 = scope_301.start_list(false, Some("Tag"));
for item_303 in var_302 {
#[allow(unused_mut)]
let mut entry_305 = list_304.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_305, item_303);
}
list_304.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_create_usage_limit(
input: &crate::input::CreateUsageLimitInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "CreateUsageLimit", "2012-12-01");
#[allow(unused_mut)]
let mut scope_306 = writer.prefix("ClusterIdentifier");
if let Some(var_307) = &input.cluster_identifier {
scope_306.string(var_307);
}
#[allow(unused_mut)]
let mut scope_308 = writer.prefix("FeatureType");
if let Some(var_309) = &input.feature_type {
scope_308.string(var_309.as_str());
}
#[allow(unused_mut)]
let mut scope_310 = writer.prefix("LimitType");
if let Some(var_311) = &input.limit_type {
scope_310.string(var_311.as_str());
}
#[allow(unused_mut)]
let mut scope_312 = writer.prefix("Amount");
{
scope_312.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.amount).into()),
);
}
#[allow(unused_mut)]
let mut scope_313 = writer.prefix("Period");
if let Some(var_314) = &input.period {
scope_313.string(var_314.as_str());
}
#[allow(unused_mut)]
let mut scope_315 = writer.prefix("BreachAction");
if let Some(var_316) = &input.breach_action {
scope_315.string(var_316.as_str());
}
#[allow(unused_mut)]
let mut scope_317 = writer.prefix("Tags");
if let Some(var_318) = &input.tags {
let mut list_320 = scope_317.start_list(false, Some("Tag"));
for item_319 in var_318 {
#[allow(unused_mut)]
let mut entry_321 = list_320.entry();
crate::query_ser::serialize_structure_crate_model_tag(entry_321, item_319);
}
list_320.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_deauthorize_data_share(
input: &crate::input::DeauthorizeDataShareInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeauthorizeDataShare", "2012-12-01");
#[allow(unused_mut)]
let mut scope_322 = writer.prefix("DataShareArn");
if let Some(var_323) = &input.data_share_arn {
scope_322.string(var_323);
}
#[allow(unused_mut)]
let mut scope_324 = writer.prefix("ConsumerIdentifier");
if let Some(var_325) = &input.consumer_identifier {
scope_324.string(var_325);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_authentication_profile(
input: &crate::input::DeleteAuthenticationProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteAuthenticationProfile", "2012-12-01");
#[allow(unused_mut)]
let mut scope_326 = writer.prefix("AuthenticationProfileName");
if let Some(var_327) = &input.authentication_profile_name {
scope_326.string(var_327);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_cluster(
input: &crate::input::DeleteClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteCluster", "2012-12-01");
#[allow(unused_mut)]
let mut scope_328 = writer.prefix("ClusterIdentifier");
if let Some(var_329) = &input.cluster_identifier {
scope_328.string(var_329);
}
#[allow(unused_mut)]
let mut scope_330 = writer.prefix("SkipFinalClusterSnapshot");
if input.skip_final_cluster_snapshot {
scope_330.boolean(input.skip_final_cluster_snapshot);
}
#[allow(unused_mut)]
let mut scope_331 = writer.prefix("FinalClusterSnapshotIdentifier");
if let Some(var_332) = &input.final_cluster_snapshot_identifier {
scope_331.string(var_332);
}
#[allow(unused_mut)]
let mut scope_333 = writer.prefix("FinalClusterSnapshotRetentionPeriod");
if let Some(var_334) = &input.final_cluster_snapshot_retention_period {
scope_333.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_334).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_cluster_parameter_group(
input: &crate::input::DeleteClusterParameterGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteClusterParameterGroup", "2012-12-01");
#[allow(unused_mut)]
let mut scope_335 = writer.prefix("ParameterGroupName");
if let Some(var_336) = &input.parameter_group_name {
scope_335.string(var_336);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_cluster_security_group(
input: &crate::input::DeleteClusterSecurityGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteClusterSecurityGroup", "2012-12-01");
#[allow(unused_mut)]
let mut scope_337 = writer.prefix("ClusterSecurityGroupName");
if let Some(var_338) = &input.cluster_security_group_name {
scope_337.string(var_338);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_cluster_snapshot(
input: &crate::input::DeleteClusterSnapshotInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteClusterSnapshot", "2012-12-01");
#[allow(unused_mut)]
let mut scope_339 = writer.prefix("SnapshotIdentifier");
if let Some(var_340) = &input.snapshot_identifier {
scope_339.string(var_340);
}
#[allow(unused_mut)]
let mut scope_341 = writer.prefix("SnapshotClusterIdentifier");
if let Some(var_342) = &input.snapshot_cluster_identifier {
scope_341.string(var_342);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_cluster_subnet_group(
input: &crate::input::DeleteClusterSubnetGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteClusterSubnetGroup", "2012-12-01");
#[allow(unused_mut)]
let mut scope_343 = writer.prefix("ClusterSubnetGroupName");
if let Some(var_344) = &input.cluster_subnet_group_name {
scope_343.string(var_344);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_endpoint_access(
input: &crate::input::DeleteEndpointAccessInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteEndpointAccess", "2012-12-01");
#[allow(unused_mut)]
let mut scope_345 = writer.prefix("EndpointName");
if let Some(var_346) = &input.endpoint_name {
scope_345.string(var_346);
}
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, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteEventSubscription", "2012-12-01");
#[allow(unused_mut)]
let mut scope_347 = writer.prefix("SubscriptionName");
if let Some(var_348) = &input.subscription_name {
scope_347.string(var_348);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_hsm_client_certificate(
input: &crate::input::DeleteHsmClientCertificateInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteHsmClientCertificate", "2012-12-01");
#[allow(unused_mut)]
let mut scope_349 = writer.prefix("HsmClientCertificateIdentifier");
if let Some(var_350) = &input.hsm_client_certificate_identifier {
scope_349.string(var_350);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_hsm_configuration(
input: &crate::input::DeleteHsmConfigurationInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteHsmConfiguration", "2012-12-01");
#[allow(unused_mut)]
let mut scope_351 = writer.prefix("HsmConfigurationIdentifier");
if let Some(var_352) = &input.hsm_configuration_identifier {
scope_351.string(var_352);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_partner(
input: &crate::input::DeletePartnerInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeletePartner", "2012-12-01");
#[allow(unused_mut)]
let mut scope_353 = writer.prefix("AccountId");
if let Some(var_354) = &input.account_id {
scope_353.string(var_354);
}
#[allow(unused_mut)]
let mut scope_355 = writer.prefix("ClusterIdentifier");
if let Some(var_356) = &input.cluster_identifier {
scope_355.string(var_356);
}
#[allow(unused_mut)]
let mut scope_357 = writer.prefix("DatabaseName");
if let Some(var_358) = &input.database_name {
scope_357.string(var_358);
}
#[allow(unused_mut)]
let mut scope_359 = writer.prefix("PartnerName");
if let Some(var_360) = &input.partner_name {
scope_359.string(var_360);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_scheduled_action(
input: &crate::input::DeleteScheduledActionInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteScheduledAction", "2012-12-01");
#[allow(unused_mut)]
let mut scope_361 = writer.prefix("ScheduledActionName");
if let Some(var_362) = &input.scheduled_action_name {
scope_361.string(var_362);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_snapshot_copy_grant(
input: &crate::input::DeleteSnapshotCopyGrantInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteSnapshotCopyGrant", "2012-12-01");
#[allow(unused_mut)]
let mut scope_363 = writer.prefix("SnapshotCopyGrantName");
if let Some(var_364) = &input.snapshot_copy_grant_name {
scope_363.string(var_364);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_snapshot_schedule(
input: &crate::input::DeleteSnapshotScheduleInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DeleteSnapshotSchedule", "2012-12-01");
#[allow(unused_mut)]
let mut scope_365 = writer.prefix("ScheduleIdentifier");
if let Some(var_366) = &input.schedule_identifier {
scope_365.string(var_366);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_tags(
input: &crate::input::DeleteTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteTags", "2012-12-01");
#[allow(unused_mut)]
let mut scope_367 = writer.prefix("ResourceName");
if let Some(var_368) = &input.resource_name {
scope_367.string(var_368);
}
#[allow(unused_mut)]
let mut scope_369 = writer.prefix("TagKeys");
if let Some(var_370) = &input.tag_keys {
let mut list_372 = scope_369.start_list(false, Some("TagKey"));
for item_371 in var_370 {
#[allow(unused_mut)]
let mut entry_373 = list_372.entry();
entry_373.string(item_371);
}
list_372.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_delete_usage_limit(
input: &crate::input::DeleteUsageLimitInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DeleteUsageLimit", "2012-12-01");
#[allow(unused_mut)]
let mut scope_374 = writer.prefix("UsageLimitId");
if let Some(var_375) = &input.usage_limit_id {
scope_374.string(var_375);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_account_attributes(
input: &crate::input::DescribeAccountAttributesInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeAccountAttributes", "2012-12-01");
#[allow(unused_mut)]
let mut scope_376 = writer.prefix("AttributeNames");
if let Some(var_377) = &input.attribute_names {
let mut list_379 = scope_376.start_list(false, Some("AttributeName"));
for item_378 in var_377 {
#[allow(unused_mut)]
let mut entry_380 = list_379.entry();
entry_380.string(item_378);
}
list_379.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_authentication_profiles(
input: &crate::input::DescribeAuthenticationProfilesInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeAuthenticationProfiles",
"2012-12-01",
);
#[allow(unused_mut)]
let mut scope_381 = writer.prefix("AuthenticationProfileName");
if let Some(var_382) = &input.authentication_profile_name {
scope_381.string(var_382);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_cluster_db_revisions(
input: &crate::input::DescribeClusterDbRevisionsInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeClusterDbRevisions", "2012-12-01");
#[allow(unused_mut)]
let mut scope_383 = writer.prefix("ClusterIdentifier");
if let Some(var_384) = &input.cluster_identifier {
scope_383.string(var_384);
}
#[allow(unused_mut)]
let mut scope_385 = writer.prefix("MaxRecords");
if let Some(var_386) = &input.max_records {
scope_385.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_386).into()),
);
}
#[allow(unused_mut)]
let mut scope_387 = writer.prefix("Marker");
if let Some(var_388) = &input.marker {
scope_387.string(var_388);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_cluster_parameter_groups(
input: &crate::input::DescribeClusterParameterGroupsInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeClusterParameterGroups",
"2012-12-01",
);
#[allow(unused_mut)]
let mut scope_389 = writer.prefix("ParameterGroupName");
if let Some(var_390) = &input.parameter_group_name {
scope_389.string(var_390);
}
#[allow(unused_mut)]
let mut scope_391 = writer.prefix("MaxRecords");
if let Some(var_392) = &input.max_records {
scope_391.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_392).into()),
);
}
#[allow(unused_mut)]
let mut scope_393 = writer.prefix("Marker");
if let Some(var_394) = &input.marker {
scope_393.string(var_394);
}
#[allow(unused_mut)]
let mut scope_395 = writer.prefix("TagKeys");
if let Some(var_396) = &input.tag_keys {
let mut list_398 = scope_395.start_list(false, Some("TagKey"));
for item_397 in var_396 {
#[allow(unused_mut)]
let mut entry_399 = list_398.entry();
entry_399.string(item_397);
}
list_398.finish();
}
#[allow(unused_mut)]
let mut scope_400 = writer.prefix("TagValues");
if let Some(var_401) = &input.tag_values {
let mut list_403 = scope_400.start_list(false, Some("TagValue"));
for item_402 in var_401 {
#[allow(unused_mut)]
let mut entry_404 = list_403.entry();
entry_404.string(item_402);
}
list_403.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_cluster_parameters(
input: &crate::input::DescribeClusterParametersInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeClusterParameters", "2012-12-01");
#[allow(unused_mut)]
let mut scope_405 = writer.prefix("ParameterGroupName");
if let Some(var_406) = &input.parameter_group_name {
scope_405.string(var_406);
}
#[allow(unused_mut)]
let mut scope_407 = writer.prefix("Source");
if let Some(var_408) = &input.source {
scope_407.string(var_408);
}
#[allow(unused_mut)]
let mut scope_409 = writer.prefix("MaxRecords");
if let Some(var_410) = &input.max_records {
scope_409.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_410).into()),
);
}
#[allow(unused_mut)]
let mut scope_411 = writer.prefix("Marker");
if let Some(var_412) = &input.marker {
scope_411.string(var_412);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_clusters(
input: &crate::input::DescribeClustersInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeClusters", "2012-12-01");
#[allow(unused_mut)]
let mut scope_413 = writer.prefix("ClusterIdentifier");
if let Some(var_414) = &input.cluster_identifier {
scope_413.string(var_414);
}
#[allow(unused_mut)]
let mut scope_415 = writer.prefix("MaxRecords");
if let Some(var_416) = &input.max_records {
scope_415.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_416).into()),
);
}
#[allow(unused_mut)]
let mut scope_417 = writer.prefix("Marker");
if let Some(var_418) = &input.marker {
scope_417.string(var_418);
}
#[allow(unused_mut)]
let mut scope_419 = writer.prefix("TagKeys");
if let Some(var_420) = &input.tag_keys {
let mut list_422 = scope_419.start_list(false, Some("TagKey"));
for item_421 in var_420 {
#[allow(unused_mut)]
let mut entry_423 = list_422.entry();
entry_423.string(item_421);
}
list_422.finish();
}
#[allow(unused_mut)]
let mut scope_424 = writer.prefix("TagValues");
if let Some(var_425) = &input.tag_values {
let mut list_427 = scope_424.start_list(false, Some("TagValue"));
for item_426 in var_425 {
#[allow(unused_mut)]
let mut entry_428 = list_427.entry();
entry_428.string(item_426);
}
list_427.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_cluster_security_groups(
input: &crate::input::DescribeClusterSecurityGroupsInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeClusterSecurityGroups", "2012-12-01");
#[allow(unused_mut)]
let mut scope_429 = writer.prefix("ClusterSecurityGroupName");
if let Some(var_430) = &input.cluster_security_group_name {
scope_429.string(var_430);
}
#[allow(unused_mut)]
let mut scope_431 = writer.prefix("MaxRecords");
if let Some(var_432) = &input.max_records {
scope_431.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_432).into()),
);
}
#[allow(unused_mut)]
let mut scope_433 = writer.prefix("Marker");
if let Some(var_434) = &input.marker {
scope_433.string(var_434);
}
#[allow(unused_mut)]
let mut scope_435 = writer.prefix("TagKeys");
if let Some(var_436) = &input.tag_keys {
let mut list_438 = scope_435.start_list(false, Some("TagKey"));
for item_437 in var_436 {
#[allow(unused_mut)]
let mut entry_439 = list_438.entry();
entry_439.string(item_437);
}
list_438.finish();
}
#[allow(unused_mut)]
let mut scope_440 = writer.prefix("TagValues");
if let Some(var_441) = &input.tag_values {
let mut list_443 = scope_440.start_list(false, Some("TagValue"));
for item_442 in var_441 {
#[allow(unused_mut)]
let mut entry_444 = list_443.entry();
entry_444.string(item_442);
}
list_443.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_cluster_snapshots(
input: &crate::input::DescribeClusterSnapshotsInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeClusterSnapshots", "2012-12-01");
#[allow(unused_mut)]
let mut scope_445 = writer.prefix("ClusterIdentifier");
if let Some(var_446) = &input.cluster_identifier {
scope_445.string(var_446);
}
#[allow(unused_mut)]
let mut scope_447 = writer.prefix("SnapshotIdentifier");
if let Some(var_448) = &input.snapshot_identifier {
scope_447.string(var_448);
}
#[allow(unused_mut)]
let mut scope_449 = writer.prefix("SnapshotType");
if let Some(var_450) = &input.snapshot_type {
scope_449.string(var_450);
}
#[allow(unused_mut)]
let mut scope_451 = writer.prefix("StartTime");
if let Some(var_452) = &input.start_time {
scope_451.instant(var_452, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_453 = writer.prefix("EndTime");
if let Some(var_454) = &input.end_time {
scope_453.instant(var_454, aws_smithy_types::instant::Format::DateTime);
}
#[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);
}
#[allow(unused_mut)]
let mut scope_459 = writer.prefix("OwnerAccount");
if let Some(var_460) = &input.owner_account {
scope_459.string(var_460);
}
#[allow(unused_mut)]
let mut scope_461 = writer.prefix("TagKeys");
if let Some(var_462) = &input.tag_keys {
let mut list_464 = scope_461.start_list(false, Some("TagKey"));
for item_463 in var_462 {
#[allow(unused_mut)]
let mut entry_465 = list_464.entry();
entry_465.string(item_463);
}
list_464.finish();
}
#[allow(unused_mut)]
let mut scope_466 = writer.prefix("TagValues");
if let Some(var_467) = &input.tag_values {
let mut list_469 = scope_466.start_list(false, Some("TagValue"));
for item_468 in var_467 {
#[allow(unused_mut)]
let mut entry_470 = list_469.entry();
entry_470.string(item_468);
}
list_469.finish();
}
#[allow(unused_mut)]
let mut scope_471 = writer.prefix("ClusterExists");
if let Some(var_472) = &input.cluster_exists {
scope_471.boolean(*var_472);
}
#[allow(unused_mut)]
let mut scope_473 = writer.prefix("SortingEntities");
if let Some(var_474) = &input.sorting_entities {
let mut list_476 = scope_473.start_list(false, Some("SnapshotSortingEntity"));
for item_475 in var_474 {
#[allow(unused_mut)]
let mut entry_477 = list_476.entry();
crate::query_ser::serialize_structure_crate_model_snapshot_sorting_entity(
entry_477, item_475,
);
}
list_476.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_cluster_subnet_groups(
input: &crate::input::DescribeClusterSubnetGroupsInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeClusterSubnetGroups", "2012-12-01");
#[allow(unused_mut)]
let mut scope_478 = writer.prefix("ClusterSubnetGroupName");
if let Some(var_479) = &input.cluster_subnet_group_name {
scope_478.string(var_479);
}
#[allow(unused_mut)]
let mut scope_480 = writer.prefix("MaxRecords");
if let Some(var_481) = &input.max_records {
scope_480.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_481).into()),
);
}
#[allow(unused_mut)]
let mut scope_482 = writer.prefix("Marker");
if let Some(var_483) = &input.marker {
scope_482.string(var_483);
}
#[allow(unused_mut)]
let mut scope_484 = writer.prefix("TagKeys");
if let Some(var_485) = &input.tag_keys {
let mut list_487 = scope_484.start_list(false, Some("TagKey"));
for item_486 in var_485 {
#[allow(unused_mut)]
let mut entry_488 = list_487.entry();
entry_488.string(item_486);
}
list_487.finish();
}
#[allow(unused_mut)]
let mut scope_489 = writer.prefix("TagValues");
if let Some(var_490) = &input.tag_values {
let mut list_492 = scope_489.start_list(false, Some("TagValue"));
for item_491 in var_490 {
#[allow(unused_mut)]
let mut entry_493 = list_492.entry();
entry_493.string(item_491);
}
list_492.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_cluster_tracks(
input: &crate::input::DescribeClusterTracksInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeClusterTracks", "2012-12-01");
#[allow(unused_mut)]
let mut scope_494 = writer.prefix("MaintenanceTrackName");
if let Some(var_495) = &input.maintenance_track_name {
scope_494.string(var_495);
}
#[allow(unused_mut)]
let mut scope_496 = writer.prefix("MaxRecords");
if let Some(var_497) = &input.max_records {
scope_496.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_497).into()),
);
}
#[allow(unused_mut)]
let mut scope_498 = writer.prefix("Marker");
if let Some(var_499) = &input.marker {
scope_498.string(var_499);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_cluster_versions(
input: &crate::input::DescribeClusterVersionsInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeClusterVersions", "2012-12-01");
#[allow(unused_mut)]
let mut scope_500 = writer.prefix("ClusterVersion");
if let Some(var_501) = &input.cluster_version {
scope_500.string(var_501);
}
#[allow(unused_mut)]
let mut scope_502 = writer.prefix("ClusterParameterGroupFamily");
if let Some(var_503) = &input.cluster_parameter_group_family {
scope_502.string(var_503);
}
#[allow(unused_mut)]
let mut scope_504 = writer.prefix("MaxRecords");
if let Some(var_505) = &input.max_records {
scope_504.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_505).into()),
);
}
#[allow(unused_mut)]
let mut scope_506 = writer.prefix("Marker");
if let Some(var_507) = &input.marker {
scope_506.string(var_507);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_data_shares(
input: &crate::input::DescribeDataSharesInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeDataShares", "2012-12-01");
#[allow(unused_mut)]
let mut scope_508 = writer.prefix("DataShareArn");
if let Some(var_509) = &input.data_share_arn {
scope_508.string(var_509);
}
#[allow(unused_mut)]
let mut scope_510 = writer.prefix("MaxRecords");
if let Some(var_511) = &input.max_records {
scope_510.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_511).into()),
);
}
#[allow(unused_mut)]
let mut scope_512 = writer.prefix("Marker");
if let Some(var_513) = &input.marker {
scope_512.string(var_513);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_data_shares_for_consumer(
input: &crate::input::DescribeDataSharesForConsumerInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeDataSharesForConsumer", "2012-12-01");
#[allow(unused_mut)]
let mut scope_514 = writer.prefix("ConsumerArn");
if let Some(var_515) = &input.consumer_arn {
scope_514.string(var_515);
}
#[allow(unused_mut)]
let mut scope_516 = writer.prefix("Status");
if let Some(var_517) = &input.status {
scope_516.string(var_517.as_str());
}
#[allow(unused_mut)]
let mut scope_518 = writer.prefix("MaxRecords");
if let Some(var_519) = &input.max_records {
scope_518.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_519).into()),
);
}
#[allow(unused_mut)]
let mut scope_520 = writer.prefix("Marker");
if let Some(var_521) = &input.marker {
scope_520.string(var_521);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_data_shares_for_producer(
input: &crate::input::DescribeDataSharesForProducerInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeDataSharesForProducer", "2012-12-01");
#[allow(unused_mut)]
let mut scope_522 = writer.prefix("ProducerArn");
if let Some(var_523) = &input.producer_arn {
scope_522.string(var_523);
}
#[allow(unused_mut)]
let mut scope_524 = writer.prefix("Status");
if let Some(var_525) = &input.status {
scope_524.string(var_525.as_str());
}
#[allow(unused_mut)]
let mut scope_526 = writer.prefix("MaxRecords");
if let Some(var_527) = &input.max_records {
scope_526.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_527).into()),
);
}
#[allow(unused_mut)]
let mut scope_528 = writer.prefix("Marker");
if let Some(var_529) = &input.marker {
scope_528.string(var_529);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_default_cluster_parameters(
input: &crate::input::DescribeDefaultClusterParametersInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeDefaultClusterParameters",
"2012-12-01",
);
#[allow(unused_mut)]
let mut scope_530 = writer.prefix("ParameterGroupFamily");
if let Some(var_531) = &input.parameter_group_family {
scope_530.string(var_531);
}
#[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_endpoint_access(
input: &crate::input::DescribeEndpointAccessInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeEndpointAccess", "2012-12-01");
#[allow(unused_mut)]
let mut scope_536 = writer.prefix("ClusterIdentifier");
if let Some(var_537) = &input.cluster_identifier {
scope_536.string(var_537);
}
#[allow(unused_mut)]
let mut scope_538 = writer.prefix("ResourceOwner");
if let Some(var_539) = &input.resource_owner {
scope_538.string(var_539);
}
#[allow(unused_mut)]
let mut scope_540 = writer.prefix("EndpointName");
if let Some(var_541) = &input.endpoint_name {
scope_540.string(var_541);
}
#[allow(unused_mut)]
let mut scope_542 = writer.prefix("VpcId");
if let Some(var_543) = &input.vpc_id {
scope_542.string(var_543);
}
#[allow(unused_mut)]
let mut scope_544 = writer.prefix("MaxRecords");
if let Some(var_545) = &input.max_records {
scope_544.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_545).into()),
);
}
#[allow(unused_mut)]
let mut scope_546 = writer.prefix("Marker");
if let Some(var_547) = &input.marker {
scope_546.string(var_547);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_endpoint_authorization(
input: &crate::input::DescribeEndpointAuthorizationInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeEndpointAuthorization", "2012-12-01");
#[allow(unused_mut)]
let mut scope_548 = writer.prefix("ClusterIdentifier");
if let Some(var_549) = &input.cluster_identifier {
scope_548.string(var_549);
}
#[allow(unused_mut)]
let mut scope_550 = writer.prefix("Account");
if let Some(var_551) = &input.account {
scope_550.string(var_551);
}
#[allow(unused_mut)]
let mut scope_552 = writer.prefix("Grantee");
if let Some(var_553) = &input.grantee {
scope_552.boolean(*var_553);
}
#[allow(unused_mut)]
let mut scope_554 = writer.prefix("MaxRecords");
if let Some(var_555) = &input.max_records {
scope_554.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_555).into()),
);
}
#[allow(unused_mut)]
let mut scope_556 = writer.prefix("Marker");
if let Some(var_557) = &input.marker {
scope_556.string(var_557);
}
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, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeEventCategories", "2012-12-01");
#[allow(unused_mut)]
let mut scope_558 = writer.prefix("SourceType");
if let Some(var_559) = &input.source_type {
scope_558.string(var_559);
}
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, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeEvents", "2012-12-01");
#[allow(unused_mut)]
let mut scope_560 = writer.prefix("SourceIdentifier");
if let Some(var_561) = &input.source_identifier {
scope_560.string(var_561);
}
#[allow(unused_mut)]
let mut scope_562 = writer.prefix("SourceType");
if let Some(var_563) = &input.source_type {
scope_562.string(var_563.as_str());
}
#[allow(unused_mut)]
let mut scope_564 = writer.prefix("StartTime");
if let Some(var_565) = &input.start_time {
scope_564.instant(var_565, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_566 = writer.prefix("EndTime");
if let Some(var_567) = &input.end_time {
scope_566.instant(var_567, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_568 = writer.prefix("Duration");
if let Some(var_569) = &input.duration {
scope_568.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_569).into()),
);
}
#[allow(unused_mut)]
let mut scope_570 = writer.prefix("MaxRecords");
if let Some(var_571) = &input.max_records {
scope_570.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_571).into()),
);
}
#[allow(unused_mut)]
let mut scope_572 = writer.prefix("Marker");
if let Some(var_573) = &input.marker {
scope_572.string(var_573);
}
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, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeEventSubscriptions", "2012-12-01");
#[allow(unused_mut)]
let mut scope_574 = writer.prefix("SubscriptionName");
if let Some(var_575) = &input.subscription_name {
scope_574.string(var_575);
}
#[allow(unused_mut)]
let mut scope_576 = writer.prefix("MaxRecords");
if let Some(var_577) = &input.max_records {
scope_576.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_577).into()),
);
}
#[allow(unused_mut)]
let mut scope_578 = writer.prefix("Marker");
if let Some(var_579) = &input.marker {
scope_578.string(var_579);
}
#[allow(unused_mut)]
let mut scope_580 = writer.prefix("TagKeys");
if let Some(var_581) = &input.tag_keys {
let mut list_583 = scope_580.start_list(false, Some("TagKey"));
for item_582 in var_581 {
#[allow(unused_mut)]
let mut entry_584 = list_583.entry();
entry_584.string(item_582);
}
list_583.finish();
}
#[allow(unused_mut)]
let mut scope_585 = writer.prefix("TagValues");
if let Some(var_586) = &input.tag_values {
let mut list_588 = scope_585.start_list(false, Some("TagValue"));
for item_587 in var_586 {
#[allow(unused_mut)]
let mut entry_589 = list_588.entry();
entry_589.string(item_587);
}
list_588.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_hsm_client_certificates(
input: &crate::input::DescribeHsmClientCertificatesInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeHsmClientCertificates", "2012-12-01");
#[allow(unused_mut)]
let mut scope_590 = writer.prefix("HsmClientCertificateIdentifier");
if let Some(var_591) = &input.hsm_client_certificate_identifier {
scope_590.string(var_591);
}
#[allow(unused_mut)]
let mut scope_592 = writer.prefix("MaxRecords");
if let Some(var_593) = &input.max_records {
scope_592.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_593).into()),
);
}
#[allow(unused_mut)]
let mut scope_594 = writer.prefix("Marker");
if let Some(var_595) = &input.marker {
scope_594.string(var_595);
}
#[allow(unused_mut)]
let mut scope_596 = writer.prefix("TagKeys");
if let Some(var_597) = &input.tag_keys {
let mut list_599 = scope_596.start_list(false, Some("TagKey"));
for item_598 in var_597 {
#[allow(unused_mut)]
let mut entry_600 = list_599.entry();
entry_600.string(item_598);
}
list_599.finish();
}
#[allow(unused_mut)]
let mut scope_601 = writer.prefix("TagValues");
if let Some(var_602) = &input.tag_values {
let mut list_604 = scope_601.start_list(false, Some("TagValue"));
for item_603 in var_602 {
#[allow(unused_mut)]
let mut entry_605 = list_604.entry();
entry_605.string(item_603);
}
list_604.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_hsm_configurations(
input: &crate::input::DescribeHsmConfigurationsInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeHsmConfigurations", "2012-12-01");
#[allow(unused_mut)]
let mut scope_606 = writer.prefix("HsmConfigurationIdentifier");
if let Some(var_607) = &input.hsm_configuration_identifier {
scope_606.string(var_607);
}
#[allow(unused_mut)]
let mut scope_608 = writer.prefix("MaxRecords");
if let Some(var_609) = &input.max_records {
scope_608.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_609).into()),
);
}
#[allow(unused_mut)]
let mut scope_610 = writer.prefix("Marker");
if let Some(var_611) = &input.marker {
scope_610.string(var_611);
}
#[allow(unused_mut)]
let mut scope_612 = writer.prefix("TagKeys");
if let Some(var_613) = &input.tag_keys {
let mut list_615 = scope_612.start_list(false, Some("TagKey"));
for item_614 in var_613 {
#[allow(unused_mut)]
let mut entry_616 = list_615.entry();
entry_616.string(item_614);
}
list_615.finish();
}
#[allow(unused_mut)]
let mut scope_617 = writer.prefix("TagValues");
if let Some(var_618) = &input.tag_values {
let mut list_620 = scope_617.start_list(false, Some("TagValue"));
for item_619 in var_618 {
#[allow(unused_mut)]
let mut entry_621 = list_620.entry();
entry_621.string(item_619);
}
list_620.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_logging_status(
input: &crate::input::DescribeLoggingStatusInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeLoggingStatus", "2012-12-01");
#[allow(unused_mut)]
let mut scope_622 = writer.prefix("ClusterIdentifier");
if let Some(var_623) = &input.cluster_identifier {
scope_622.string(var_623);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_node_configuration_options(
input: &crate::input::DescribeNodeConfigurationOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeNodeConfigurationOptions",
"2012-12-01",
);
#[allow(unused_mut)]
let mut scope_624 = writer.prefix("ActionType");
if let Some(var_625) = &input.action_type {
scope_624.string(var_625.as_str());
}
#[allow(unused_mut)]
let mut scope_626 = writer.prefix("ClusterIdentifier");
if let Some(var_627) = &input.cluster_identifier {
scope_626.string(var_627);
}
#[allow(unused_mut)]
let mut scope_628 = writer.prefix("SnapshotIdentifier");
if let Some(var_629) = &input.snapshot_identifier {
scope_628.string(var_629);
}
#[allow(unused_mut)]
let mut scope_630 = writer.prefix("OwnerAccount");
if let Some(var_631) = &input.owner_account {
scope_630.string(var_631);
}
#[allow(unused_mut)]
let mut scope_632 = writer.prefix("Filter");
if let Some(var_633) = &input.filters {
let mut list_635 = scope_632.start_list(false, Some("NodeConfigurationOptionsFilter"));
for item_634 in var_633 {
#[allow(unused_mut)]
let mut entry_636 = list_635.entry();
crate::query_ser::serialize_structure_crate_model_node_configuration_options_filter(
entry_636, item_634,
);
}
list_635.finish();
}
#[allow(unused_mut)]
let mut scope_637 = writer.prefix("Marker");
if let Some(var_638) = &input.marker {
scope_637.string(var_638);
}
#[allow(unused_mut)]
let mut scope_639 = writer.prefix("MaxRecords");
if let Some(var_640) = &input.max_records {
scope_639.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_640).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_orderable_cluster_options(
input: &crate::input::DescribeOrderableClusterOptionsInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"DescribeOrderableClusterOptions",
"2012-12-01",
);
#[allow(unused_mut)]
let mut scope_641 = writer.prefix("ClusterVersion");
if let Some(var_642) = &input.cluster_version {
scope_641.string(var_642);
}
#[allow(unused_mut)]
let mut scope_643 = writer.prefix("NodeType");
if let Some(var_644) = &input.node_type {
scope_643.string(var_644);
}
#[allow(unused_mut)]
let mut scope_645 = writer.prefix("MaxRecords");
if let Some(var_646) = &input.max_records {
scope_645.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_646).into()),
);
}
#[allow(unused_mut)]
let mut scope_647 = writer.prefix("Marker");
if let Some(var_648) = &input.marker {
scope_647.string(var_648);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_partners(
input: &crate::input::DescribePartnersInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribePartners", "2012-12-01");
#[allow(unused_mut)]
let mut scope_649 = writer.prefix("AccountId");
if let Some(var_650) = &input.account_id {
scope_649.string(var_650);
}
#[allow(unused_mut)]
let mut scope_651 = writer.prefix("ClusterIdentifier");
if let Some(var_652) = &input.cluster_identifier {
scope_651.string(var_652);
}
#[allow(unused_mut)]
let mut scope_653 = writer.prefix("DatabaseName");
if let Some(var_654) = &input.database_name {
scope_653.string(var_654);
}
#[allow(unused_mut)]
let mut scope_655 = writer.prefix("PartnerName");
if let Some(var_656) = &input.partner_name {
scope_655.string(var_656);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_reserved_node_offerings(
input: &crate::input::DescribeReservedNodeOfferingsInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeReservedNodeOfferings", "2012-12-01");
#[allow(unused_mut)]
let mut scope_657 = writer.prefix("ReservedNodeOfferingId");
if let Some(var_658) = &input.reserved_node_offering_id {
scope_657.string(var_658);
}
#[allow(unused_mut)]
let mut scope_659 = writer.prefix("MaxRecords");
if let Some(var_660) = &input.max_records {
scope_659.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_660).into()),
);
}
#[allow(unused_mut)]
let mut scope_661 = writer.prefix("Marker");
if let Some(var_662) = &input.marker {
scope_661.string(var_662);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_reserved_nodes(
input: &crate::input::DescribeReservedNodesInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeReservedNodes", "2012-12-01");
#[allow(unused_mut)]
let mut scope_663 = writer.prefix("ReservedNodeId");
if let Some(var_664) = &input.reserved_node_id {
scope_663.string(var_664);
}
#[allow(unused_mut)]
let mut scope_665 = writer.prefix("MaxRecords");
if let Some(var_666) = &input.max_records {
scope_665.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_666).into()),
);
}
#[allow(unused_mut)]
let mut scope_667 = writer.prefix("Marker");
if let Some(var_668) = &input.marker {
scope_667.string(var_668);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_resize(
input: &crate::input::DescribeResizeInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeResize", "2012-12-01");
#[allow(unused_mut)]
let mut scope_669 = writer.prefix("ClusterIdentifier");
if let Some(var_670) = &input.cluster_identifier {
scope_669.string(var_670);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_scheduled_actions(
input: &crate::input::DescribeScheduledActionsInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeScheduledActions", "2012-12-01");
#[allow(unused_mut)]
let mut scope_671 = writer.prefix("ScheduledActionName");
if let Some(var_672) = &input.scheduled_action_name {
scope_671.string(var_672);
}
#[allow(unused_mut)]
let mut scope_673 = writer.prefix("TargetActionType");
if let Some(var_674) = &input.target_action_type {
scope_673.string(var_674.as_str());
}
#[allow(unused_mut)]
let mut scope_675 = writer.prefix("StartTime");
if let Some(var_676) = &input.start_time {
scope_675.instant(var_676, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_677 = writer.prefix("EndTime");
if let Some(var_678) = &input.end_time {
scope_677.instant(var_678, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_679 = writer.prefix("Active");
if let Some(var_680) = &input.active {
scope_679.boolean(*var_680);
}
#[allow(unused_mut)]
let mut scope_681 = writer.prefix("Filters");
if let Some(var_682) = &input.filters {
let mut list_684 = scope_681.start_list(false, Some("ScheduledActionFilter"));
for item_683 in var_682 {
#[allow(unused_mut)]
let mut entry_685 = list_684.entry();
crate::query_ser::serialize_structure_crate_model_scheduled_action_filter(
entry_685, item_683,
);
}
list_684.finish();
}
#[allow(unused_mut)]
let mut scope_686 = writer.prefix("Marker");
if let Some(var_687) = &input.marker {
scope_686.string(var_687);
}
#[allow(unused_mut)]
let mut scope_688 = writer.prefix("MaxRecords");
if let Some(var_689) = &input.max_records {
scope_688.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_689).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_snapshot_copy_grants(
input: &crate::input::DescribeSnapshotCopyGrantsInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeSnapshotCopyGrants", "2012-12-01");
#[allow(unused_mut)]
let mut scope_690 = writer.prefix("SnapshotCopyGrantName");
if let Some(var_691) = &input.snapshot_copy_grant_name {
scope_690.string(var_691);
}
#[allow(unused_mut)]
let mut scope_692 = writer.prefix("MaxRecords");
if let Some(var_693) = &input.max_records {
scope_692.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_693).into()),
);
}
#[allow(unused_mut)]
let mut scope_694 = writer.prefix("Marker");
if let Some(var_695) = &input.marker {
scope_694.string(var_695);
}
#[allow(unused_mut)]
let mut scope_696 = writer.prefix("TagKeys");
if let Some(var_697) = &input.tag_keys {
let mut list_699 = scope_696.start_list(false, Some("TagKey"));
for item_698 in var_697 {
#[allow(unused_mut)]
let mut entry_700 = list_699.entry();
entry_700.string(item_698);
}
list_699.finish();
}
#[allow(unused_mut)]
let mut scope_701 = writer.prefix("TagValues");
if let Some(var_702) = &input.tag_values {
let mut list_704 = scope_701.start_list(false, Some("TagValue"));
for item_703 in var_702 {
#[allow(unused_mut)]
let mut entry_705 = list_704.entry();
entry_705.string(item_703);
}
list_704.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_snapshot_schedules(
input: &crate::input::DescribeSnapshotSchedulesInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeSnapshotSchedules", "2012-12-01");
#[allow(unused_mut)]
let mut scope_706 = writer.prefix("ClusterIdentifier");
if let Some(var_707) = &input.cluster_identifier {
scope_706.string(var_707);
}
#[allow(unused_mut)]
let mut scope_708 = writer.prefix("ScheduleIdentifier");
if let Some(var_709) = &input.schedule_identifier {
scope_708.string(var_709);
}
#[allow(unused_mut)]
let mut scope_710 = writer.prefix("TagKeys");
if let Some(var_711) = &input.tag_keys {
let mut list_713 = scope_710.start_list(false, Some("TagKey"));
for item_712 in var_711 {
#[allow(unused_mut)]
let mut entry_714 = list_713.entry();
entry_714.string(item_712);
}
list_713.finish();
}
#[allow(unused_mut)]
let mut scope_715 = writer.prefix("TagValues");
if let Some(var_716) = &input.tag_values {
let mut list_718 = scope_715.start_list(false, Some("TagValue"));
for item_717 in var_716 {
#[allow(unused_mut)]
let mut entry_719 = list_718.entry();
entry_719.string(item_717);
}
list_718.finish();
}
#[allow(unused_mut)]
let mut scope_720 = writer.prefix("Marker");
if let Some(var_721) = &input.marker {
scope_720.string(var_721);
}
#[allow(unused_mut)]
let mut scope_722 = writer.prefix("MaxRecords");
if let Some(var_723) = &input.max_records {
scope_722.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_723).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_storage(
input: &crate::input::DescribeStorageInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let _ = input;
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeStorage", "2012-12-01");
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_table_restore_status(
input: &crate::input::DescribeTableRestoreStatusInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeTableRestoreStatus", "2012-12-01");
#[allow(unused_mut)]
let mut scope_724 = writer.prefix("ClusterIdentifier");
if let Some(var_725) = &input.cluster_identifier {
scope_724.string(var_725);
}
#[allow(unused_mut)]
let mut scope_726 = writer.prefix("TableRestoreRequestId");
if let Some(var_727) = &input.table_restore_request_id {
scope_726.string(var_727);
}
#[allow(unused_mut)]
let mut scope_728 = writer.prefix("MaxRecords");
if let Some(var_729) = &input.max_records {
scope_728.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_729).into()),
);
}
#[allow(unused_mut)]
let mut scope_730 = writer.prefix("Marker");
if let Some(var_731) = &input.marker {
scope_730.string(var_731);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_tags(
input: &crate::input::DescribeTagsInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DescribeTags", "2012-12-01");
#[allow(unused_mut)]
let mut scope_732 = writer.prefix("ResourceName");
if let Some(var_733) = &input.resource_name {
scope_732.string(var_733);
}
#[allow(unused_mut)]
let mut scope_734 = writer.prefix("ResourceType");
if let Some(var_735) = &input.resource_type {
scope_734.string(var_735);
}
#[allow(unused_mut)]
let mut scope_736 = writer.prefix("MaxRecords");
if let Some(var_737) = &input.max_records {
scope_736.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_737).into()),
);
}
#[allow(unused_mut)]
let mut scope_738 = writer.prefix("Marker");
if let Some(var_739) = &input.marker {
scope_738.string(var_739);
}
#[allow(unused_mut)]
let mut scope_740 = writer.prefix("TagKeys");
if let Some(var_741) = &input.tag_keys {
let mut list_743 = scope_740.start_list(false, Some("TagKey"));
for item_742 in var_741 {
#[allow(unused_mut)]
let mut entry_744 = list_743.entry();
entry_744.string(item_742);
}
list_743.finish();
}
#[allow(unused_mut)]
let mut scope_745 = writer.prefix("TagValues");
if let Some(var_746) = &input.tag_values {
let mut list_748 = scope_745.start_list(false, Some("TagValue"));
for item_747 in var_746 {
#[allow(unused_mut)]
let mut entry_749 = list_748.entry();
entry_749.string(item_747);
}
list_748.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_describe_usage_limits(
input: &crate::input::DescribeUsageLimitsInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DescribeUsageLimits", "2012-12-01");
#[allow(unused_mut)]
let mut scope_750 = writer.prefix("UsageLimitId");
if let Some(var_751) = &input.usage_limit_id {
scope_750.string(var_751);
}
#[allow(unused_mut)]
let mut scope_752 = writer.prefix("ClusterIdentifier");
if let Some(var_753) = &input.cluster_identifier {
scope_752.string(var_753);
}
#[allow(unused_mut)]
let mut scope_754 = writer.prefix("FeatureType");
if let Some(var_755) = &input.feature_type {
scope_754.string(var_755.as_str());
}
#[allow(unused_mut)]
let mut scope_756 = writer.prefix("MaxRecords");
if let Some(var_757) = &input.max_records {
scope_756.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_757).into()),
);
}
#[allow(unused_mut)]
let mut scope_758 = writer.prefix("Marker");
if let Some(var_759) = &input.marker {
scope_758.string(var_759);
}
#[allow(unused_mut)]
let mut scope_760 = writer.prefix("TagKeys");
if let Some(var_761) = &input.tag_keys {
let mut list_763 = scope_760.start_list(false, Some("TagKey"));
for item_762 in var_761 {
#[allow(unused_mut)]
let mut entry_764 = list_763.entry();
entry_764.string(item_762);
}
list_763.finish();
}
#[allow(unused_mut)]
let mut scope_765 = writer.prefix("TagValues");
if let Some(var_766) = &input.tag_values {
let mut list_768 = scope_765.start_list(false, Some("TagValue"));
for item_767 in var_766 {
#[allow(unused_mut)]
let mut entry_769 = list_768.entry();
entry_769.string(item_767);
}
list_768.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disable_logging(
input: &crate::input::DisableLoggingInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "DisableLogging", "2012-12-01");
#[allow(unused_mut)]
let mut scope_770 = writer.prefix("ClusterIdentifier");
if let Some(var_771) = &input.cluster_identifier {
scope_770.string(var_771);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disable_snapshot_copy(
input: &crate::input::DisableSnapshotCopyInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DisableSnapshotCopy", "2012-12-01");
#[allow(unused_mut)]
let mut scope_772 = writer.prefix("ClusterIdentifier");
if let Some(var_773) = &input.cluster_identifier {
scope_772.string(var_773);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_disassociate_data_share_consumer(
input: &crate::input::DisassociateDataShareConsumerInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "DisassociateDataShareConsumer", "2012-12-01");
#[allow(unused_mut)]
let mut scope_774 = writer.prefix("DataShareArn");
if let Some(var_775) = &input.data_share_arn {
scope_774.string(var_775);
}
#[allow(unused_mut)]
let mut scope_776 = writer.prefix("DisassociateEntireAccount");
if let Some(var_777) = &input.disassociate_entire_account {
scope_776.boolean(*var_777);
}
#[allow(unused_mut)]
let mut scope_778 = writer.prefix("ConsumerArn");
if let Some(var_779) = &input.consumer_arn {
scope_778.string(var_779);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_enable_logging(
input: &crate::input::EnableLoggingInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "EnableLogging", "2012-12-01");
#[allow(unused_mut)]
let mut scope_780 = writer.prefix("ClusterIdentifier");
if let Some(var_781) = &input.cluster_identifier {
scope_780.string(var_781);
}
#[allow(unused_mut)]
let mut scope_782 = writer.prefix("BucketName");
if let Some(var_783) = &input.bucket_name {
scope_782.string(var_783);
}
#[allow(unused_mut)]
let mut scope_784 = writer.prefix("S3KeyPrefix");
if let Some(var_785) = &input.s3_key_prefix {
scope_784.string(var_785);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_enable_snapshot_copy(
input: &crate::input::EnableSnapshotCopyInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "EnableSnapshotCopy", "2012-12-01");
#[allow(unused_mut)]
let mut scope_786 = writer.prefix("ClusterIdentifier");
if let Some(var_787) = &input.cluster_identifier {
scope_786.string(var_787);
}
#[allow(unused_mut)]
let mut scope_788 = writer.prefix("DestinationRegion");
if let Some(var_789) = &input.destination_region {
scope_788.string(var_789);
}
#[allow(unused_mut)]
let mut scope_790 = writer.prefix("RetentionPeriod");
if let Some(var_791) = &input.retention_period {
scope_790.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_791).into()),
);
}
#[allow(unused_mut)]
let mut scope_792 = writer.prefix("SnapshotCopyGrantName");
if let Some(var_793) = &input.snapshot_copy_grant_name {
scope_792.string(var_793);
}
#[allow(unused_mut)]
let mut scope_794 = writer.prefix("ManualSnapshotRetentionPeriod");
if let Some(var_795) = &input.manual_snapshot_retention_period {
scope_794.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_795).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_cluster_credentials(
input: &crate::input::GetClusterCredentialsInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "GetClusterCredentials", "2012-12-01");
#[allow(unused_mut)]
let mut scope_796 = writer.prefix("DbUser");
if let Some(var_797) = &input.db_user {
scope_796.string(var_797);
}
#[allow(unused_mut)]
let mut scope_798 = writer.prefix("DbName");
if let Some(var_799) = &input.db_name {
scope_798.string(var_799);
}
#[allow(unused_mut)]
let mut scope_800 = writer.prefix("ClusterIdentifier");
if let Some(var_801) = &input.cluster_identifier {
scope_800.string(var_801);
}
#[allow(unused_mut)]
let mut scope_802 = writer.prefix("DurationSeconds");
if let Some(var_803) = &input.duration_seconds {
scope_802.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_803).into()),
);
}
#[allow(unused_mut)]
let mut scope_804 = writer.prefix("AutoCreate");
if let Some(var_805) = &input.auto_create {
scope_804.boolean(*var_805);
}
#[allow(unused_mut)]
let mut scope_806 = writer.prefix("DbGroups");
if let Some(var_807) = &input.db_groups {
let mut list_809 = scope_806.start_list(false, Some("DbGroup"));
for item_808 in var_807 {
#[allow(unused_mut)]
let mut entry_810 = list_809.entry();
entry_810.string(item_808);
}
list_809.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_get_reserved_node_exchange_offerings(
input: &crate::input::GetReservedNodeExchangeOfferingsInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"GetReservedNodeExchangeOfferings",
"2012-12-01",
);
#[allow(unused_mut)]
let mut scope_811 = writer.prefix("ReservedNodeId");
if let Some(var_812) = &input.reserved_node_id {
scope_811.string(var_812);
}
#[allow(unused_mut)]
let mut scope_813 = writer.prefix("MaxRecords");
if let Some(var_814) = &input.max_records {
scope_813.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_814).into()),
);
}
#[allow(unused_mut)]
let mut scope_815 = writer.prefix("Marker");
if let Some(var_816) = &input.marker {
scope_815.string(var_816);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_aqua_configuration(
input: &crate::input::ModifyAquaConfigurationInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyAquaConfiguration", "2012-12-01");
#[allow(unused_mut)]
let mut scope_817 = writer.prefix("ClusterIdentifier");
if let Some(var_818) = &input.cluster_identifier {
scope_817.string(var_818);
}
#[allow(unused_mut)]
let mut scope_819 = writer.prefix("AquaConfigurationStatus");
if let Some(var_820) = &input.aqua_configuration_status {
scope_819.string(var_820.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_authentication_profile(
input: &crate::input::ModifyAuthenticationProfileInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyAuthenticationProfile", "2012-12-01");
#[allow(unused_mut)]
let mut scope_821 = writer.prefix("AuthenticationProfileName");
if let Some(var_822) = &input.authentication_profile_name {
scope_821.string(var_822);
}
#[allow(unused_mut)]
let mut scope_823 = writer.prefix("AuthenticationProfileContent");
if let Some(var_824) = &input.authentication_profile_content {
scope_823.string(var_824);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_cluster(
input: &crate::input::ModifyClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ModifyCluster", "2012-12-01");
#[allow(unused_mut)]
let mut scope_825 = writer.prefix("ClusterIdentifier");
if let Some(var_826) = &input.cluster_identifier {
scope_825.string(var_826);
}
#[allow(unused_mut)]
let mut scope_827 = writer.prefix("ClusterType");
if let Some(var_828) = &input.cluster_type {
scope_827.string(var_828);
}
#[allow(unused_mut)]
let mut scope_829 = writer.prefix("NodeType");
if let Some(var_830) = &input.node_type {
scope_829.string(var_830);
}
#[allow(unused_mut)]
let mut scope_831 = writer.prefix("NumberOfNodes");
if let Some(var_832) = &input.number_of_nodes {
scope_831.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_832).into()),
);
}
#[allow(unused_mut)]
let mut scope_833 = writer.prefix("ClusterSecurityGroups");
if let Some(var_834) = &input.cluster_security_groups {
let mut list_836 = scope_833.start_list(false, Some("ClusterSecurityGroupName"));
for item_835 in var_834 {
#[allow(unused_mut)]
let mut entry_837 = list_836.entry();
entry_837.string(item_835);
}
list_836.finish();
}
#[allow(unused_mut)]
let mut scope_838 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_839) = &input.vpc_security_group_ids {
let mut list_841 = scope_838.start_list(false, Some("VpcSecurityGroupId"));
for item_840 in var_839 {
#[allow(unused_mut)]
let mut entry_842 = list_841.entry();
entry_842.string(item_840);
}
list_841.finish();
}
#[allow(unused_mut)]
let mut scope_843 = writer.prefix("MasterUserPassword");
if let Some(var_844) = &input.master_user_password {
scope_843.string(var_844);
}
#[allow(unused_mut)]
let mut scope_845 = writer.prefix("ClusterParameterGroupName");
if let Some(var_846) = &input.cluster_parameter_group_name {
scope_845.string(var_846);
}
#[allow(unused_mut)]
let mut scope_847 = writer.prefix("AutomatedSnapshotRetentionPeriod");
if let Some(var_848) = &input.automated_snapshot_retention_period {
scope_847.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_848).into()),
);
}
#[allow(unused_mut)]
let mut scope_849 = writer.prefix("ManualSnapshotRetentionPeriod");
if let Some(var_850) = &input.manual_snapshot_retention_period {
scope_849.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_850).into()),
);
}
#[allow(unused_mut)]
let mut scope_851 = writer.prefix("PreferredMaintenanceWindow");
if let Some(var_852) = &input.preferred_maintenance_window {
scope_851.string(var_852);
}
#[allow(unused_mut)]
let mut scope_853 = writer.prefix("ClusterVersion");
if let Some(var_854) = &input.cluster_version {
scope_853.string(var_854);
}
#[allow(unused_mut)]
let mut scope_855 = writer.prefix("AllowVersionUpgrade");
if let Some(var_856) = &input.allow_version_upgrade {
scope_855.boolean(*var_856);
}
#[allow(unused_mut)]
let mut scope_857 = writer.prefix("HsmClientCertificateIdentifier");
if let Some(var_858) = &input.hsm_client_certificate_identifier {
scope_857.string(var_858);
}
#[allow(unused_mut)]
let mut scope_859 = writer.prefix("HsmConfigurationIdentifier");
if let Some(var_860) = &input.hsm_configuration_identifier {
scope_859.string(var_860);
}
#[allow(unused_mut)]
let mut scope_861 = writer.prefix("NewClusterIdentifier");
if let Some(var_862) = &input.new_cluster_identifier {
scope_861.string(var_862);
}
#[allow(unused_mut)]
let mut scope_863 = writer.prefix("PubliclyAccessible");
if let Some(var_864) = &input.publicly_accessible {
scope_863.boolean(*var_864);
}
#[allow(unused_mut)]
let mut scope_865 = writer.prefix("ElasticIp");
if let Some(var_866) = &input.elastic_ip {
scope_865.string(var_866);
}
#[allow(unused_mut)]
let mut scope_867 = writer.prefix("EnhancedVpcRouting");
if let Some(var_868) = &input.enhanced_vpc_routing {
scope_867.boolean(*var_868);
}
#[allow(unused_mut)]
let mut scope_869 = writer.prefix("MaintenanceTrackName");
if let Some(var_870) = &input.maintenance_track_name {
scope_869.string(var_870);
}
#[allow(unused_mut)]
let mut scope_871 = writer.prefix("Encrypted");
if let Some(var_872) = &input.encrypted {
scope_871.boolean(*var_872);
}
#[allow(unused_mut)]
let mut scope_873 = writer.prefix("KmsKeyId");
if let Some(var_874) = &input.kms_key_id {
scope_873.string(var_874);
}
#[allow(unused_mut)]
let mut scope_875 = writer.prefix("AvailabilityZoneRelocation");
if let Some(var_876) = &input.availability_zone_relocation {
scope_875.boolean(*var_876);
}
#[allow(unused_mut)]
let mut scope_877 = writer.prefix("AvailabilityZone");
if let Some(var_878) = &input.availability_zone {
scope_877.string(var_878);
}
#[allow(unused_mut)]
let mut scope_879 = writer.prefix("Port");
if let Some(var_880) = &input.port {
scope_879.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_880).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_cluster_db_revision(
input: &crate::input::ModifyClusterDbRevisionInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyClusterDbRevision", "2012-12-01");
#[allow(unused_mut)]
let mut scope_881 = writer.prefix("ClusterIdentifier");
if let Some(var_882) = &input.cluster_identifier {
scope_881.string(var_882);
}
#[allow(unused_mut)]
let mut scope_883 = writer.prefix("RevisionTarget");
if let Some(var_884) = &input.revision_target {
scope_883.string(var_884);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_cluster_iam_roles(
input: &crate::input::ModifyClusterIamRolesInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyClusterIamRoles", "2012-12-01");
#[allow(unused_mut)]
let mut scope_885 = writer.prefix("ClusterIdentifier");
if let Some(var_886) = &input.cluster_identifier {
scope_885.string(var_886);
}
#[allow(unused_mut)]
let mut scope_887 = writer.prefix("AddIamRoles");
if let Some(var_888) = &input.add_iam_roles {
let mut list_890 = scope_887.start_list(false, Some("IamRoleArn"));
for item_889 in var_888 {
#[allow(unused_mut)]
let mut entry_891 = list_890.entry();
entry_891.string(item_889);
}
list_890.finish();
}
#[allow(unused_mut)]
let mut scope_892 = writer.prefix("RemoveIamRoles");
if let Some(var_893) = &input.remove_iam_roles {
let mut list_895 = scope_892.start_list(false, Some("IamRoleArn"));
for item_894 in var_893 {
#[allow(unused_mut)]
let mut entry_896 = list_895.entry();
entry_896.string(item_894);
}
list_895.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_cluster_maintenance(
input: &crate::input::ModifyClusterMaintenanceInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyClusterMaintenance", "2012-12-01");
#[allow(unused_mut)]
let mut scope_897 = writer.prefix("ClusterIdentifier");
if let Some(var_898) = &input.cluster_identifier {
scope_897.string(var_898);
}
#[allow(unused_mut)]
let mut scope_899 = writer.prefix("DeferMaintenance");
if let Some(var_900) = &input.defer_maintenance {
scope_899.boolean(*var_900);
}
#[allow(unused_mut)]
let mut scope_901 = writer.prefix("DeferMaintenanceIdentifier");
if let Some(var_902) = &input.defer_maintenance_identifier {
scope_901.string(var_902);
}
#[allow(unused_mut)]
let mut scope_903 = writer.prefix("DeferMaintenanceStartTime");
if let Some(var_904) = &input.defer_maintenance_start_time {
scope_903.instant(var_904, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_905 = writer.prefix("DeferMaintenanceEndTime");
if let Some(var_906) = &input.defer_maintenance_end_time {
scope_905.instant(var_906, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_907 = writer.prefix("DeferMaintenanceDuration");
if let Some(var_908) = &input.defer_maintenance_duration {
scope_907.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_908).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_cluster_parameter_group(
input: &crate::input::ModifyClusterParameterGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyClusterParameterGroup", "2012-12-01");
#[allow(unused_mut)]
let mut scope_909 = writer.prefix("ParameterGroupName");
if let Some(var_910) = &input.parameter_group_name {
scope_909.string(var_910);
}
#[allow(unused_mut)]
let mut scope_911 = writer.prefix("Parameters");
if let Some(var_912) = &input.parameters {
let mut list_914 = scope_911.start_list(false, Some("Parameter"));
for item_913 in var_912 {
#[allow(unused_mut)]
let mut entry_915 = list_914.entry();
crate::query_ser::serialize_structure_crate_model_parameter(entry_915, item_913);
}
list_914.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_cluster_snapshot(
input: &crate::input::ModifyClusterSnapshotInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyClusterSnapshot", "2012-12-01");
#[allow(unused_mut)]
let mut scope_916 = writer.prefix("SnapshotIdentifier");
if let Some(var_917) = &input.snapshot_identifier {
scope_916.string(var_917);
}
#[allow(unused_mut)]
let mut scope_918 = writer.prefix("ManualSnapshotRetentionPeriod");
if let Some(var_919) = &input.manual_snapshot_retention_period {
scope_918.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_919).into()),
);
}
#[allow(unused_mut)]
let mut scope_920 = writer.prefix("Force");
if input.force {
scope_920.boolean(input.force);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_cluster_snapshot_schedule(
input: &crate::input::ModifyClusterSnapshotScheduleInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyClusterSnapshotSchedule", "2012-12-01");
#[allow(unused_mut)]
let mut scope_921 = writer.prefix("ClusterIdentifier");
if let Some(var_922) = &input.cluster_identifier {
scope_921.string(var_922);
}
#[allow(unused_mut)]
let mut scope_923 = writer.prefix("ScheduleIdentifier");
if let Some(var_924) = &input.schedule_identifier {
scope_923.string(var_924);
}
#[allow(unused_mut)]
let mut scope_925 = writer.prefix("DisassociateSchedule");
if let Some(var_926) = &input.disassociate_schedule {
scope_925.boolean(*var_926);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_cluster_subnet_group(
input: &crate::input::ModifyClusterSubnetGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyClusterSubnetGroup", "2012-12-01");
#[allow(unused_mut)]
let mut scope_927 = writer.prefix("ClusterSubnetGroupName");
if let Some(var_928) = &input.cluster_subnet_group_name {
scope_927.string(var_928);
}
#[allow(unused_mut)]
let mut scope_929 = writer.prefix("Description");
if let Some(var_930) = &input.description {
scope_929.string(var_930);
}
#[allow(unused_mut)]
let mut scope_931 = writer.prefix("SubnetIds");
if let Some(var_932) = &input.subnet_ids {
let mut list_934 = scope_931.start_list(false, Some("SubnetIdentifier"));
for item_933 in var_932 {
#[allow(unused_mut)]
let mut entry_935 = list_934.entry();
entry_935.string(item_933);
}
list_934.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_endpoint_access(
input: &crate::input::ModifyEndpointAccessInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyEndpointAccess", "2012-12-01");
#[allow(unused_mut)]
let mut scope_936 = writer.prefix("EndpointName");
if let Some(var_937) = &input.endpoint_name {
scope_936.string(var_937);
}
#[allow(unused_mut)]
let mut scope_938 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_939) = &input.vpc_security_group_ids {
let mut list_941 = scope_938.start_list(false, Some("VpcSecurityGroupId"));
for item_940 in var_939 {
#[allow(unused_mut)]
let mut entry_942 = list_941.entry();
entry_942.string(item_940);
}
list_941.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, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyEventSubscription", "2012-12-01");
#[allow(unused_mut)]
let mut scope_943 = writer.prefix("SubscriptionName");
if let Some(var_944) = &input.subscription_name {
scope_943.string(var_944);
}
#[allow(unused_mut)]
let mut scope_945 = writer.prefix("SnsTopicArn");
if let Some(var_946) = &input.sns_topic_arn {
scope_945.string(var_946);
}
#[allow(unused_mut)]
let mut scope_947 = writer.prefix("SourceType");
if let Some(var_948) = &input.source_type {
scope_947.string(var_948);
}
#[allow(unused_mut)]
let mut scope_949 = writer.prefix("SourceIds");
if let Some(var_950) = &input.source_ids {
let mut list_952 = scope_949.start_list(false, Some("SourceId"));
for item_951 in var_950 {
#[allow(unused_mut)]
let mut entry_953 = list_952.entry();
entry_953.string(item_951);
}
list_952.finish();
}
#[allow(unused_mut)]
let mut scope_954 = writer.prefix("EventCategories");
if let Some(var_955) = &input.event_categories {
let mut list_957 = scope_954.start_list(false, Some("EventCategory"));
for item_956 in var_955 {
#[allow(unused_mut)]
let mut entry_958 = list_957.entry();
entry_958.string(item_956);
}
list_957.finish();
}
#[allow(unused_mut)]
let mut scope_959 = writer.prefix("Severity");
if let Some(var_960) = &input.severity {
scope_959.string(var_960);
}
#[allow(unused_mut)]
let mut scope_961 = writer.prefix("Enabled");
if let Some(var_962) = &input.enabled {
scope_961.boolean(*var_962);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_scheduled_action(
input: &crate::input::ModifyScheduledActionInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifyScheduledAction", "2012-12-01");
#[allow(unused_mut)]
let mut scope_963 = writer.prefix("ScheduledActionName");
if let Some(var_964) = &input.scheduled_action_name {
scope_963.string(var_964);
}
#[allow(unused_mut)]
let mut scope_965 = writer.prefix("TargetAction");
if let Some(var_966) = &input.target_action {
crate::query_ser::serialize_structure_crate_model_scheduled_action_type(scope_965, var_966);
}
#[allow(unused_mut)]
let mut scope_967 = writer.prefix("Schedule");
if let Some(var_968) = &input.schedule {
scope_967.string(var_968);
}
#[allow(unused_mut)]
let mut scope_969 = writer.prefix("IamRole");
if let Some(var_970) = &input.iam_role {
scope_969.string(var_970);
}
#[allow(unused_mut)]
let mut scope_971 = writer.prefix("ScheduledActionDescription");
if let Some(var_972) = &input.scheduled_action_description {
scope_971.string(var_972);
}
#[allow(unused_mut)]
let mut scope_973 = writer.prefix("StartTime");
if let Some(var_974) = &input.start_time {
scope_973.instant(var_974, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_975 = writer.prefix("EndTime");
if let Some(var_976) = &input.end_time {
scope_975.instant(var_976, aws_smithy_types::instant::Format::DateTime);
}
#[allow(unused_mut)]
let mut scope_977 = writer.prefix("Enable");
if let Some(var_978) = &input.enable {
scope_977.boolean(*var_978);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_snapshot_copy_retention_period(
input: &crate::input::ModifySnapshotCopyRetentionPeriodInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"ModifySnapshotCopyRetentionPeriod",
"2012-12-01",
);
#[allow(unused_mut)]
let mut scope_979 = writer.prefix("ClusterIdentifier");
if let Some(var_980) = &input.cluster_identifier {
scope_979.string(var_980);
}
#[allow(unused_mut)]
let mut scope_981 = writer.prefix("RetentionPeriod");
{
scope_981.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.retention_period).into()),
);
}
#[allow(unused_mut)]
let mut scope_982 = writer.prefix("Manual");
if input.manual {
scope_982.boolean(input.manual);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_snapshot_schedule(
input: &crate::input::ModifySnapshotScheduleInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ModifySnapshotSchedule", "2012-12-01");
#[allow(unused_mut)]
let mut scope_983 = writer.prefix("ScheduleIdentifier");
if let Some(var_984) = &input.schedule_identifier {
scope_983.string(var_984);
}
#[allow(unused_mut)]
let mut scope_985 = writer.prefix("ScheduleDefinitions");
if let Some(var_986) = &input.schedule_definitions {
let mut list_988 = scope_985.start_list(false, Some("ScheduleDefinition"));
for item_987 in var_986 {
#[allow(unused_mut)]
let mut entry_989 = list_988.entry();
entry_989.string(item_987);
}
list_988.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_modify_usage_limit(
input: &crate::input::ModifyUsageLimitInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ModifyUsageLimit", "2012-12-01");
#[allow(unused_mut)]
let mut scope_990 = writer.prefix("UsageLimitId");
if let Some(var_991) = &input.usage_limit_id {
scope_990.string(var_991);
}
#[allow(unused_mut)]
let mut scope_992 = writer.prefix("Amount");
if let Some(var_993) = &input.amount {
scope_992.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_993).into()),
);
}
#[allow(unused_mut)]
let mut scope_994 = writer.prefix("BreachAction");
if let Some(var_995) = &input.breach_action {
scope_994.string(var_995.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_pause_cluster(
input: &crate::input::PauseClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "PauseCluster", "2012-12-01");
#[allow(unused_mut)]
let mut scope_996 = writer.prefix("ClusterIdentifier");
if let Some(var_997) = &input.cluster_identifier {
scope_996.string(var_997);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_purchase_reserved_node_offering(
input: &crate::input::PurchaseReservedNodeOfferingInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "PurchaseReservedNodeOffering", "2012-12-01");
#[allow(unused_mut)]
let mut scope_998 = writer.prefix("ReservedNodeOfferingId");
if let Some(var_999) = &input.reserved_node_offering_id {
scope_998.string(var_999);
}
#[allow(unused_mut)]
let mut scope_1000 = writer.prefix("NodeCount");
if let Some(var_1001) = &input.node_count {
scope_1000.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1001).into()),
);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_reboot_cluster(
input: &crate::input::RebootClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "RebootCluster", "2012-12-01");
#[allow(unused_mut)]
let mut scope_1002 = writer.prefix("ClusterIdentifier");
if let Some(var_1003) = &input.cluster_identifier {
scope_1002.string(var_1003);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_reject_data_share(
input: &crate::input::RejectDataShareInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "RejectDataShare", "2012-12-01");
#[allow(unused_mut)]
let mut scope_1004 = writer.prefix("DataShareArn");
if let Some(var_1005) = &input.data_share_arn {
scope_1004.string(var_1005);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_reset_cluster_parameter_group(
input: &crate::input::ResetClusterParameterGroupInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "ResetClusterParameterGroup", "2012-12-01");
#[allow(unused_mut)]
let mut scope_1006 = writer.prefix("ParameterGroupName");
if let Some(var_1007) = &input.parameter_group_name {
scope_1006.string(var_1007);
}
#[allow(unused_mut)]
let mut scope_1008 = writer.prefix("ResetAllParameters");
if input.reset_all_parameters {
scope_1008.boolean(input.reset_all_parameters);
}
#[allow(unused_mut)]
let mut scope_1009 = writer.prefix("Parameters");
if let Some(var_1010) = &input.parameters {
let mut list_1012 = scope_1009.start_list(false, Some("Parameter"));
for item_1011 in var_1010 {
#[allow(unused_mut)]
let mut entry_1013 = list_1012.entry();
crate::query_ser::serialize_structure_crate_model_parameter(entry_1013, item_1011);
}
list_1012.finish();
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_resize_cluster(
input: &crate::input::ResizeClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ResizeCluster", "2012-12-01");
#[allow(unused_mut)]
let mut scope_1014 = writer.prefix("ClusterIdentifier");
if let Some(var_1015) = &input.cluster_identifier {
scope_1014.string(var_1015);
}
#[allow(unused_mut)]
let mut scope_1016 = writer.prefix("ClusterType");
if let Some(var_1017) = &input.cluster_type {
scope_1016.string(var_1017);
}
#[allow(unused_mut)]
let mut scope_1018 = writer.prefix("NodeType");
if let Some(var_1019) = &input.node_type {
scope_1018.string(var_1019);
}
#[allow(unused_mut)]
let mut scope_1020 = writer.prefix("NumberOfNodes");
if let Some(var_1021) = &input.number_of_nodes {
scope_1020.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1021).into()),
);
}
#[allow(unused_mut)]
let mut scope_1022 = writer.prefix("Classic");
if let Some(var_1023) = &input.classic {
scope_1022.boolean(*var_1023);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_restore_from_cluster_snapshot(
input: &crate::input::RestoreFromClusterSnapshotInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RestoreFromClusterSnapshot", "2012-12-01");
#[allow(unused_mut)]
let mut scope_1024 = writer.prefix("ClusterIdentifier");
if let Some(var_1025) = &input.cluster_identifier {
scope_1024.string(var_1025);
}
#[allow(unused_mut)]
let mut scope_1026 = writer.prefix("SnapshotIdentifier");
if let Some(var_1027) = &input.snapshot_identifier {
scope_1026.string(var_1027);
}
#[allow(unused_mut)]
let mut scope_1028 = writer.prefix("SnapshotClusterIdentifier");
if let Some(var_1029) = &input.snapshot_cluster_identifier {
scope_1028.string(var_1029);
}
#[allow(unused_mut)]
let mut scope_1030 = writer.prefix("Port");
if let Some(var_1031) = &input.port {
scope_1030.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1031).into()),
);
}
#[allow(unused_mut)]
let mut scope_1032 = writer.prefix("AvailabilityZone");
if let Some(var_1033) = &input.availability_zone {
scope_1032.string(var_1033);
}
#[allow(unused_mut)]
let mut scope_1034 = writer.prefix("AllowVersionUpgrade");
if let Some(var_1035) = &input.allow_version_upgrade {
scope_1034.boolean(*var_1035);
}
#[allow(unused_mut)]
let mut scope_1036 = writer.prefix("ClusterSubnetGroupName");
if let Some(var_1037) = &input.cluster_subnet_group_name {
scope_1036.string(var_1037);
}
#[allow(unused_mut)]
let mut scope_1038 = writer.prefix("PubliclyAccessible");
if let Some(var_1039) = &input.publicly_accessible {
scope_1038.boolean(*var_1039);
}
#[allow(unused_mut)]
let mut scope_1040 = writer.prefix("OwnerAccount");
if let Some(var_1041) = &input.owner_account {
scope_1040.string(var_1041);
}
#[allow(unused_mut)]
let mut scope_1042 = writer.prefix("HsmClientCertificateIdentifier");
if let Some(var_1043) = &input.hsm_client_certificate_identifier {
scope_1042.string(var_1043);
}
#[allow(unused_mut)]
let mut scope_1044 = writer.prefix("HsmConfigurationIdentifier");
if let Some(var_1045) = &input.hsm_configuration_identifier {
scope_1044.string(var_1045);
}
#[allow(unused_mut)]
let mut scope_1046 = writer.prefix("ElasticIp");
if let Some(var_1047) = &input.elastic_ip {
scope_1046.string(var_1047);
}
#[allow(unused_mut)]
let mut scope_1048 = writer.prefix("ClusterParameterGroupName");
if let Some(var_1049) = &input.cluster_parameter_group_name {
scope_1048.string(var_1049);
}
#[allow(unused_mut)]
let mut scope_1050 = writer.prefix("ClusterSecurityGroups");
if let Some(var_1051) = &input.cluster_security_groups {
let mut list_1053 = scope_1050.start_list(false, Some("ClusterSecurityGroupName"));
for item_1052 in var_1051 {
#[allow(unused_mut)]
let mut entry_1054 = list_1053.entry();
entry_1054.string(item_1052);
}
list_1053.finish();
}
#[allow(unused_mut)]
let mut scope_1055 = writer.prefix("VpcSecurityGroupIds");
if let Some(var_1056) = &input.vpc_security_group_ids {
let mut list_1058 = scope_1055.start_list(false, Some("VpcSecurityGroupId"));
for item_1057 in var_1056 {
#[allow(unused_mut)]
let mut entry_1059 = list_1058.entry();
entry_1059.string(item_1057);
}
list_1058.finish();
}
#[allow(unused_mut)]
let mut scope_1060 = writer.prefix("PreferredMaintenanceWindow");
if let Some(var_1061) = &input.preferred_maintenance_window {
scope_1060.string(var_1061);
}
#[allow(unused_mut)]
let mut scope_1062 = writer.prefix("AutomatedSnapshotRetentionPeriod");
if let Some(var_1063) = &input.automated_snapshot_retention_period {
scope_1062.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1063).into()),
);
}
#[allow(unused_mut)]
let mut scope_1064 = writer.prefix("ManualSnapshotRetentionPeriod");
if let Some(var_1065) = &input.manual_snapshot_retention_period {
scope_1064.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1065).into()),
);
}
#[allow(unused_mut)]
let mut scope_1066 = writer.prefix("KmsKeyId");
if let Some(var_1067) = &input.kms_key_id {
scope_1066.string(var_1067);
}
#[allow(unused_mut)]
let mut scope_1068 = writer.prefix("NodeType");
if let Some(var_1069) = &input.node_type {
scope_1068.string(var_1069);
}
#[allow(unused_mut)]
let mut scope_1070 = writer.prefix("EnhancedVpcRouting");
if let Some(var_1071) = &input.enhanced_vpc_routing {
scope_1070.boolean(*var_1071);
}
#[allow(unused_mut)]
let mut scope_1072 = writer.prefix("AdditionalInfo");
if let Some(var_1073) = &input.additional_info {
scope_1072.string(var_1073);
}
#[allow(unused_mut)]
let mut scope_1074 = writer.prefix("IamRoles");
if let Some(var_1075) = &input.iam_roles {
let mut list_1077 = scope_1074.start_list(false, Some("IamRoleArn"));
for item_1076 in var_1075 {
#[allow(unused_mut)]
let mut entry_1078 = list_1077.entry();
entry_1078.string(item_1076);
}
list_1077.finish();
}
#[allow(unused_mut)]
let mut scope_1079 = writer.prefix("MaintenanceTrackName");
if let Some(var_1080) = &input.maintenance_track_name {
scope_1079.string(var_1080);
}
#[allow(unused_mut)]
let mut scope_1081 = writer.prefix("SnapshotScheduleIdentifier");
if let Some(var_1082) = &input.snapshot_schedule_identifier {
scope_1081.string(var_1082);
}
#[allow(unused_mut)]
let mut scope_1083 = writer.prefix("NumberOfNodes");
if let Some(var_1084) = &input.number_of_nodes {
scope_1083.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_1084).into()),
);
}
#[allow(unused_mut)]
let mut scope_1085 = writer.prefix("AvailabilityZoneRelocation");
if let Some(var_1086) = &input.availability_zone_relocation {
scope_1085.boolean(*var_1086);
}
#[allow(unused_mut)]
let mut scope_1087 = writer.prefix("AquaConfigurationStatus");
if let Some(var_1088) = &input.aqua_configuration_status {
scope_1087.string(var_1088.as_str());
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_restore_table_from_cluster_snapshot(
input: &crate::input::RestoreTableFromClusterSnapshotInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"RestoreTableFromClusterSnapshot",
"2012-12-01",
);
#[allow(unused_mut)]
let mut scope_1089 = writer.prefix("ClusterIdentifier");
if let Some(var_1090) = &input.cluster_identifier {
scope_1089.string(var_1090);
}
#[allow(unused_mut)]
let mut scope_1091 = writer.prefix("SnapshotIdentifier");
if let Some(var_1092) = &input.snapshot_identifier {
scope_1091.string(var_1092);
}
#[allow(unused_mut)]
let mut scope_1093 = writer.prefix("SourceDatabaseName");
if let Some(var_1094) = &input.source_database_name {
scope_1093.string(var_1094);
}
#[allow(unused_mut)]
let mut scope_1095 = writer.prefix("SourceSchemaName");
if let Some(var_1096) = &input.source_schema_name {
scope_1095.string(var_1096);
}
#[allow(unused_mut)]
let mut scope_1097 = writer.prefix("SourceTableName");
if let Some(var_1098) = &input.source_table_name {
scope_1097.string(var_1098);
}
#[allow(unused_mut)]
let mut scope_1099 = writer.prefix("TargetDatabaseName");
if let Some(var_1100) = &input.target_database_name {
scope_1099.string(var_1100);
}
#[allow(unused_mut)]
let mut scope_1101 = writer.prefix("TargetSchemaName");
if let Some(var_1102) = &input.target_schema_name {
scope_1101.string(var_1102);
}
#[allow(unused_mut)]
let mut scope_1103 = writer.prefix("NewTableName");
if let Some(var_1104) = &input.new_table_name {
scope_1103.string(var_1104);
}
#[allow(unused_mut)]
let mut scope_1105 = writer.prefix("EnableCaseSensitiveIdentifier");
if let Some(var_1106) = &input.enable_case_sensitive_identifier {
scope_1105.boolean(*var_1106);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_resume_cluster(
input: &crate::input::ResumeClusterInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(&mut out, "ResumeCluster", "2012-12-01");
#[allow(unused_mut)]
let mut scope_1107 = writer.prefix("ClusterIdentifier");
if let Some(var_1108) = &input.cluster_identifier {
scope_1107.string(var_1108);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_revoke_cluster_security_group_ingress(
input: &crate::input::RevokeClusterSecurityGroupIngressInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer = aws_smithy_query::QueryWriter::new(
&mut out,
"RevokeClusterSecurityGroupIngress",
"2012-12-01",
);
#[allow(unused_mut)]
let mut scope_1109 = writer.prefix("ClusterSecurityGroupName");
if let Some(var_1110) = &input.cluster_security_group_name {
scope_1109.string(var_1110);
}
#[allow(unused_mut)]
let mut scope_1111 = writer.prefix("CIDRIP");
if let Some(var_1112) = &input.cidrip {
scope_1111.string(var_1112);
}
#[allow(unused_mut)]
let mut scope_1113 = writer.prefix("EC2SecurityGroupName");
if let Some(var_1114) = &input.ec2_security_group_name {
scope_1113.string(var_1114);
}
#[allow(unused_mut)]
let mut scope_1115 = writer.prefix("EC2SecurityGroupOwnerId");
if let Some(var_1116) = &input.ec2_security_group_owner_id {
scope_1115.string(var_1116);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_revoke_endpoint_access(
input: &crate::input::RevokeEndpointAccessInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RevokeEndpointAccess", "2012-12-01");
#[allow(unused_mut)]
let mut scope_1117 = writer.prefix("ClusterIdentifier");
if let Some(var_1118) = &input.cluster_identifier {
scope_1117.string(var_1118);
}
#[allow(unused_mut)]
let mut scope_1119 = writer.prefix("Account");
if let Some(var_1120) = &input.account {
scope_1119.string(var_1120);
}
#[allow(unused_mut)]
let mut scope_1121 = writer.prefix("VpcIds");
if let Some(var_1122) = &input.vpc_ids {
let mut list_1124 = scope_1121.start_list(false, Some("VpcIdentifier"));
for item_1123 in var_1122 {
#[allow(unused_mut)]
let mut entry_1125 = list_1124.entry();
entry_1125.string(item_1123);
}
list_1124.finish();
}
#[allow(unused_mut)]
let mut scope_1126 = writer.prefix("Force");
if input.force {
scope_1126.boolean(input.force);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_revoke_snapshot_access(
input: &crate::input::RevokeSnapshotAccessInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RevokeSnapshotAccess", "2012-12-01");
#[allow(unused_mut)]
let mut scope_1127 = writer.prefix("SnapshotIdentifier");
if let Some(var_1128) = &input.snapshot_identifier {
scope_1127.string(var_1128);
}
#[allow(unused_mut)]
let mut scope_1129 = writer.prefix("SnapshotClusterIdentifier");
if let Some(var_1130) = &input.snapshot_cluster_identifier {
scope_1129.string(var_1130);
}
#[allow(unused_mut)]
let mut scope_1131 = writer.prefix("AccountWithRestoreAccess");
if let Some(var_1132) = &input.account_with_restore_access {
scope_1131.string(var_1132);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_rotate_encryption_key(
input: &crate::input::RotateEncryptionKeyInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "RotateEncryptionKey", "2012-12-01");
#[allow(unused_mut)]
let mut scope_1133 = writer.prefix("ClusterIdentifier");
if let Some(var_1134) = &input.cluster_identifier {
scope_1133.string(var_1134);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}
pub fn serialize_operation_crate_operation_update_partner_status(
input: &crate::input::UpdatePartnerStatusInput,
) -> Result<aws_smithy_http::body::SdkBody, std::convert::Infallible> {
let mut out = String::new();
#[allow(unused_mut)]
let mut writer =
aws_smithy_query::QueryWriter::new(&mut out, "UpdatePartnerStatus", "2012-12-01");
#[allow(unused_mut)]
let mut scope_1135 = writer.prefix("AccountId");
if let Some(var_1136) = &input.account_id {
scope_1135.string(var_1136);
}
#[allow(unused_mut)]
let mut scope_1137 = writer.prefix("ClusterIdentifier");
if let Some(var_1138) = &input.cluster_identifier {
scope_1137.string(var_1138);
}
#[allow(unused_mut)]
let mut scope_1139 = writer.prefix("DatabaseName");
if let Some(var_1140) = &input.database_name {
scope_1139.string(var_1140);
}
#[allow(unused_mut)]
let mut scope_1141 = writer.prefix("PartnerName");
if let Some(var_1142) = &input.partner_name {
scope_1141.string(var_1142);
}
#[allow(unused_mut)]
let mut scope_1143 = writer.prefix("Status");
if let Some(var_1144) = &input.status {
scope_1143.string(var_1144.as_str());
}
#[allow(unused_mut)]
let mut scope_1145 = writer.prefix("StatusMessage");
if let Some(var_1146) = &input.status_message {
scope_1145.string(var_1146);
}
writer.finish();
Ok(aws_smithy_http::body::SdkBody::from(out))
}