pub fn serialize_structure_crate_input_batch_update_cluster_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchUpdateClusterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.cluster_names {
let mut array_2 = object.key("ClusterNames").start_array();
for item_3 in var_1 {
{
array_2.value().string(item_3.as_str());
}
}
array_2.finish();
}
if let Some(var_4) = &input.service_update {
#[allow(unused_mut)]
let mut object_5 = object.key("ServiceUpdate").start_object();
crate::json_ser::serialize_structure_crate_model_service_update_request(
&mut object_5,
var_4,
)?;
object_5.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_copy_snapshot_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CopySnapshotInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_6) = &input.source_snapshot_name {
object.key("SourceSnapshotName").string(var_6.as_str());
}
if let Some(var_7) = &input.target_snapshot_name {
object.key("TargetSnapshotName").string(var_7.as_str());
}
if let Some(var_8) = &input.target_bucket {
object.key("TargetBucket").string(var_8.as_str());
}
if let Some(var_9) = &input.kms_key_id {
object.key("KmsKeyId").string(var_9.as_str());
}
if let Some(var_10) = &input.tags {
let mut array_11 = object.key("Tags").start_array();
for item_12 in var_10 {
{
#[allow(unused_mut)]
let mut object_13 = array_11.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_13, item_12)?;
object_13.finish();
}
}
array_11.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_acl_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAclInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_14) = &input.acl_name {
object.key("ACLName").string(var_14.as_str());
}
if let Some(var_15) = &input.user_names {
let mut array_16 = object.key("UserNames").start_array();
for item_17 in var_15 {
{
array_16.value().string(item_17.as_str());
}
}
array_16.finish();
}
if let Some(var_18) = &input.tags {
let mut array_19 = object.key("Tags").start_array();
for item_20 in var_18 {
{
#[allow(unused_mut)]
let mut object_21 = array_19.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_21, item_20)?;
object_21.finish();
}
}
array_19.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_cluster_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateClusterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_22) = &input.cluster_name {
object.key("ClusterName").string(var_22.as_str());
}
if let Some(var_23) = &input.node_type {
object.key("NodeType").string(var_23.as_str());
}
if let Some(var_24) = &input.parameter_group_name {
object.key("ParameterGroupName").string(var_24.as_str());
}
if let Some(var_25) = &input.description {
object.key("Description").string(var_25.as_str());
}
if let Some(var_26) = &input.num_shards {
object.key("NumShards").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_26).into()),
);
}
if let Some(var_27) = &input.num_replicas_per_shard {
object.key("NumReplicasPerShard").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_27).into()),
);
}
if let Some(var_28) = &input.subnet_group_name {
object.key("SubnetGroupName").string(var_28.as_str());
}
if let Some(var_29) = &input.security_group_ids {
let mut array_30 = object.key("SecurityGroupIds").start_array();
for item_31 in var_29 {
{
array_30.value().string(item_31.as_str());
}
}
array_30.finish();
}
if let Some(var_32) = &input.maintenance_window {
object.key("MaintenanceWindow").string(var_32.as_str());
}
if let Some(var_33) = &input.port {
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_33).into()),
);
}
if let Some(var_34) = &input.sns_topic_arn {
object.key("SnsTopicArn").string(var_34.as_str());
}
if let Some(var_35) = &input.tls_enabled {
object.key("TLSEnabled").boolean(*var_35);
}
if let Some(var_36) = &input.kms_key_id {
object.key("KmsKeyId").string(var_36.as_str());
}
if let Some(var_37) = &input.snapshot_arns {
let mut array_38 = object.key("SnapshotArns").start_array();
for item_39 in var_37 {
{
array_38.value().string(item_39.as_str());
}
}
array_38.finish();
}
if let Some(var_40) = &input.snapshot_name {
object.key("SnapshotName").string(var_40.as_str());
}
if let Some(var_41) = &input.snapshot_retention_limit {
object.key("SnapshotRetentionLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_41).into()),
);
}
if let Some(var_42) = &input.tags {
let mut array_43 = object.key("Tags").start_array();
for item_44 in var_42 {
{
#[allow(unused_mut)]
let mut object_45 = array_43.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_45, item_44)?;
object_45.finish();
}
}
array_43.finish();
}
if let Some(var_46) = &input.snapshot_window {
object.key("SnapshotWindow").string(var_46.as_str());
}
if let Some(var_47) = &input.acl_name {
object.key("ACLName").string(var_47.as_str());
}
if let Some(var_48) = &input.engine_version {
object.key("EngineVersion").string(var_48.as_str());
}
if let Some(var_49) = &input.auto_minor_version_upgrade {
object.key("AutoMinorVersionUpgrade").boolean(*var_49);
}
if let Some(var_50) = &input.data_tiering {
object.key("DataTiering").boolean(*var_50);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_parameter_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateParameterGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_51) = &input.parameter_group_name {
object.key("ParameterGroupName").string(var_51.as_str());
}
if let Some(var_52) = &input.family {
object.key("Family").string(var_52.as_str());
}
if let Some(var_53) = &input.description {
object.key("Description").string(var_53.as_str());
}
if let Some(var_54) = &input.tags {
let mut array_55 = object.key("Tags").start_array();
for item_56 in var_54 {
{
#[allow(unused_mut)]
let mut object_57 = array_55.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_57, item_56)?;
object_57.finish();
}
}
array_55.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_snapshot_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSnapshotInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_58) = &input.cluster_name {
object.key("ClusterName").string(var_58.as_str());
}
if let Some(var_59) = &input.snapshot_name {
object.key("SnapshotName").string(var_59.as_str());
}
if let Some(var_60) = &input.kms_key_id {
object.key("KmsKeyId").string(var_60.as_str());
}
if let Some(var_61) = &input.tags {
let mut array_62 = object.key("Tags").start_array();
for item_63 in var_61 {
{
#[allow(unused_mut)]
let mut object_64 = array_62.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_64, item_63)?;
object_64.finish();
}
}
array_62.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_subnet_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSubnetGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_65) = &input.subnet_group_name {
object.key("SubnetGroupName").string(var_65.as_str());
}
if let Some(var_66) = &input.description {
object.key("Description").string(var_66.as_str());
}
if let Some(var_67) = &input.subnet_ids {
let mut array_68 = object.key("SubnetIds").start_array();
for item_69 in var_67 {
{
array_68.value().string(item_69.as_str());
}
}
array_68.finish();
}
if let Some(var_70) = &input.tags {
let mut array_71 = object.key("Tags").start_array();
for item_72 in var_70 {
{
#[allow(unused_mut)]
let mut object_73 = array_71.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_73, item_72)?;
object_73.finish();
}
}
array_71.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_user_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_74) = &input.user_name {
object.key("UserName").string(var_74.as_str());
}
if let Some(var_75) = &input.authentication_mode {
#[allow(unused_mut)]
let mut object_76 = object.key("AuthenticationMode").start_object();
crate::json_ser::serialize_structure_crate_model_authentication_mode(
&mut object_76,
var_75,
)?;
object_76.finish();
}
if let Some(var_77) = &input.access_string {
object.key("AccessString").string(var_77.as_str());
}
if let Some(var_78) = &input.tags {
let mut array_79 = object.key("Tags").start_array();
for item_80 in var_78 {
{
#[allow(unused_mut)]
let mut object_81 = array_79.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_81, item_80)?;
object_81.finish();
}
}
array_79.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_acl_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAclInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_82) = &input.acl_name {
object.key("ACLName").string(var_82.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_cluster_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteClusterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_83) = &input.cluster_name {
object.key("ClusterName").string(var_83.as_str());
}
if let Some(var_84) = &input.final_snapshot_name {
object.key("FinalSnapshotName").string(var_84.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_parameter_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteParameterGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.parameter_group_name {
object.key("ParameterGroupName").string(var_85.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_snapshot_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteSnapshotInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_86) = &input.snapshot_name {
object.key("SnapshotName").string(var_86.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_subnet_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteSubnetGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_87) = &input.subnet_group_name {
object.key("SubnetGroupName").string(var_87.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_user_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_88) = &input.user_name {
object.key("UserName").string(var_88.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_ac_ls_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAcLsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.acl_name {
object.key("ACLName").string(var_89.as_str());
}
if let Some(var_90) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_90).into()),
);
}
if let Some(var_91) = &input.next_token {
object.key("NextToken").string(var_91.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_clusters_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeClustersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_92) = &input.cluster_name {
object.key("ClusterName").string(var_92.as_str());
}
if let Some(var_93) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_93).into()),
);
}
if let Some(var_94) = &input.next_token {
object.key("NextToken").string(var_94.as_str());
}
if let Some(var_95) = &input.show_shard_details {
object.key("ShowShardDetails").boolean(*var_95);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_engine_versions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEngineVersionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_96) = &input.engine_version {
object.key("EngineVersion").string(var_96.as_str());
}
if let Some(var_97) = &input.parameter_group_family {
object.key("ParameterGroupFamily").string(var_97.as_str());
}
if let Some(var_98) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_98).into()),
);
}
if let Some(var_99) = &input.next_token {
object.key("NextToken").string(var_99.as_str());
}
if input.default_only {
object.key("DefaultOnly").boolean(input.default_only);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_events_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEventsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_100) = &input.source_name {
object.key("SourceName").string(var_100.as_str());
}
if let Some(var_101) = &input.source_type {
object.key("SourceType").string(var_101.as_str());
}
if let Some(var_102) = &input.start_time {
object
.key("StartTime")
.date_time(var_102, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_103) = &input.end_time {
object
.key("EndTime")
.date_time(var_103, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_104) = &input.duration {
object.key("Duration").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_104).into()),
);
}
if let Some(var_105) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_105).into()),
);
}
if let Some(var_106) = &input.next_token {
object.key("NextToken").string(var_106.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_parameter_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeParameterGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_107) = &input.parameter_group_name {
object.key("ParameterGroupName").string(var_107.as_str());
}
if let Some(var_108) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_108).into()),
);
}
if let Some(var_109) = &input.next_token {
object.key("NextToken").string(var_109.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_parameters_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeParametersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_110) = &input.parameter_group_name {
object.key("ParameterGroupName").string(var_110.as_str());
}
if let Some(var_111) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_111).into()),
);
}
if let Some(var_112) = &input.next_token {
object.key("NextToken").string(var_112.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_reserved_nodes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeReservedNodesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_113) = &input.reservation_id {
object.key("ReservationId").string(var_113.as_str());
}
if let Some(var_114) = &input.reserved_nodes_offering_id {
object
.key("ReservedNodesOfferingId")
.string(var_114.as_str());
}
if let Some(var_115) = &input.node_type {
object.key("NodeType").string(var_115.as_str());
}
if let Some(var_116) = &input.duration {
object.key("Duration").string(var_116.as_str());
}
if let Some(var_117) = &input.offering_type {
object.key("OfferingType").string(var_117.as_str());
}
if let Some(var_118) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_118).into()),
);
}
if let Some(var_119) = &input.next_token {
object.key("NextToken").string(var_119.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_reserved_nodes_offerings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeReservedNodesOfferingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_120) = &input.reserved_nodes_offering_id {
object
.key("ReservedNodesOfferingId")
.string(var_120.as_str());
}
if let Some(var_121) = &input.node_type {
object.key("NodeType").string(var_121.as_str());
}
if let Some(var_122) = &input.duration {
object.key("Duration").string(var_122.as_str());
}
if let Some(var_123) = &input.offering_type {
object.key("OfferingType").string(var_123.as_str());
}
if let Some(var_124) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_124).into()),
);
}
if let Some(var_125) = &input.next_token {
object.key("NextToken").string(var_125.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_service_updates_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeServiceUpdatesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_126) = &input.service_update_name {
object.key("ServiceUpdateName").string(var_126.as_str());
}
if let Some(var_127) = &input.cluster_names {
let mut array_128 = object.key("ClusterNames").start_array();
for item_129 in var_127 {
{
array_128.value().string(item_129.as_str());
}
}
array_128.finish();
}
if let Some(var_130) = &input.status {
let mut array_131 = object.key("Status").start_array();
for item_132 in var_130 {
{
array_131.value().string(item_132.as_str());
}
}
array_131.finish();
}
if let Some(var_133) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_133).into()),
);
}
if let Some(var_134) = &input.next_token {
object.key("NextToken").string(var_134.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_snapshots_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeSnapshotsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_135) = &input.cluster_name {
object.key("ClusterName").string(var_135.as_str());
}
if let Some(var_136) = &input.snapshot_name {
object.key("SnapshotName").string(var_136.as_str());
}
if let Some(var_137) = &input.source {
object.key("Source").string(var_137.as_str());
}
if let Some(var_138) = &input.next_token {
object.key("NextToken").string(var_138.as_str());
}
if let Some(var_139) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_139).into()),
);
}
if let Some(var_140) = &input.show_detail {
object.key("ShowDetail").boolean(*var_140);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_subnet_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeSubnetGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_141) = &input.subnet_group_name {
object.key("SubnetGroupName").string(var_141.as_str());
}
if let Some(var_142) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_142).into()),
);
}
if let Some(var_143) = &input.next_token {
object.key("NextToken").string(var_143.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_users_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeUsersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_144) = &input.user_name {
object.key("UserName").string(var_144.as_str());
}
if let Some(var_145) = &input.filters {
let mut array_146 = object.key("Filters").start_array();
for item_147 in var_145 {
{
#[allow(unused_mut)]
let mut object_148 = array_146.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_148, item_147)?;
object_148.finish();
}
}
array_146.finish();
}
if let Some(var_149) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_149).into()),
);
}
if let Some(var_150) = &input.next_token {
object.key("NextToken").string(var_150.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_failover_shard_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::FailoverShardInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_151) = &input.cluster_name {
object.key("ClusterName").string(var_151.as_str());
}
if let Some(var_152) = &input.shard_name {
object.key("ShardName").string(var_152.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_allowed_node_type_updates_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAllowedNodeTypeUpdatesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_153) = &input.cluster_name {
object.key("ClusterName").string(var_153.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTagsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_154) = &input.resource_arn {
object.key("ResourceArn").string(var_154.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_purchase_reserved_nodes_offering_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PurchaseReservedNodesOfferingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_155) = &input.reserved_nodes_offering_id {
object
.key("ReservedNodesOfferingId")
.string(var_155.as_str());
}
if let Some(var_156) = &input.reservation_id {
object.key("ReservationId").string(var_156.as_str());
}
if let Some(var_157) = &input.node_count {
object.key("NodeCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_157).into()),
);
}
if let Some(var_158) = &input.tags {
let mut array_159 = object.key("Tags").start_array();
for item_160 in var_158 {
{
#[allow(unused_mut)]
let mut object_161 = array_159.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_161, item_160)?;
object_161.finish();
}
}
array_159.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_reset_parameter_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ResetParameterGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_162) = &input.parameter_group_name {
object.key("ParameterGroupName").string(var_162.as_str());
}
if input.all_parameters {
object.key("AllParameters").boolean(input.all_parameters);
}
if let Some(var_163) = &input.parameter_names {
let mut array_164 = object.key("ParameterNames").start_array();
for item_165 in var_163 {
{
array_164.value().string(item_165.as_str());
}
}
array_164.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_166) = &input.resource_arn {
object.key("ResourceArn").string(var_166.as_str());
}
if let Some(var_167) = &input.tags {
let mut array_168 = object.key("Tags").start_array();
for item_169 in var_167 {
{
#[allow(unused_mut)]
let mut object_170 = array_168.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_170, item_169)?;
object_170.finish();
}
}
array_168.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_untag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UntagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_171) = &input.resource_arn {
object.key("ResourceArn").string(var_171.as_str());
}
if let Some(var_172) = &input.tag_keys {
let mut array_173 = object.key("TagKeys").start_array();
for item_174 in var_172 {
{
array_173.value().string(item_174.as_str());
}
}
array_173.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_acl_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAclInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_175) = &input.acl_name {
object.key("ACLName").string(var_175.as_str());
}
if let Some(var_176) = &input.user_names_to_add {
let mut array_177 = object.key("UserNamesToAdd").start_array();
for item_178 in var_176 {
{
array_177.value().string(item_178.as_str());
}
}
array_177.finish();
}
if let Some(var_179) = &input.user_names_to_remove {
let mut array_180 = object.key("UserNamesToRemove").start_array();
for item_181 in var_179 {
{
array_180.value().string(item_181.as_str());
}
}
array_180.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_cluster_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateClusterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_182) = &input.cluster_name {
object.key("ClusterName").string(var_182.as_str());
}
if let Some(var_183) = &input.description {
object.key("Description").string(var_183.as_str());
}
if let Some(var_184) = &input.security_group_ids {
let mut array_185 = object.key("SecurityGroupIds").start_array();
for item_186 in var_184 {
{
array_185.value().string(item_186.as_str());
}
}
array_185.finish();
}
if let Some(var_187) = &input.maintenance_window {
object.key("MaintenanceWindow").string(var_187.as_str());
}
if let Some(var_188) = &input.sns_topic_arn {
object.key("SnsTopicArn").string(var_188.as_str());
}
if let Some(var_189) = &input.sns_topic_status {
object.key("SnsTopicStatus").string(var_189.as_str());
}
if let Some(var_190) = &input.parameter_group_name {
object.key("ParameterGroupName").string(var_190.as_str());
}
if let Some(var_191) = &input.snapshot_window {
object.key("SnapshotWindow").string(var_191.as_str());
}
if let Some(var_192) = &input.snapshot_retention_limit {
object.key("SnapshotRetentionLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_192).into()),
);
}
if let Some(var_193) = &input.node_type {
object.key("NodeType").string(var_193.as_str());
}
if let Some(var_194) = &input.engine_version {
object.key("EngineVersion").string(var_194.as_str());
}
if let Some(var_195) = &input.replica_configuration {
#[allow(unused_mut)]
let mut object_196 = object.key("ReplicaConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_replica_configuration_request(
&mut object_196,
var_195,
)?;
object_196.finish();
}
if let Some(var_197) = &input.shard_configuration {
#[allow(unused_mut)]
let mut object_198 = object.key("ShardConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_shard_configuration_request(
&mut object_198,
var_197,
)?;
object_198.finish();
}
if let Some(var_199) = &input.acl_name {
object.key("ACLName").string(var_199.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_parameter_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateParameterGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_200) = &input.parameter_group_name {
object.key("ParameterGroupName").string(var_200.as_str());
}
if let Some(var_201) = &input.parameter_name_values {
let mut array_202 = object.key("ParameterNameValues").start_array();
for item_203 in var_201 {
{
#[allow(unused_mut)]
let mut object_204 = array_202.value().start_object();
crate::json_ser::serialize_structure_crate_model_parameter_name_value(
&mut object_204,
item_203,
)?;
object_204.finish();
}
}
array_202.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_subnet_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSubnetGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_205) = &input.subnet_group_name {
object.key("SubnetGroupName").string(var_205.as_str());
}
if let Some(var_206) = &input.description {
object.key("Description").string(var_206.as_str());
}
if let Some(var_207) = &input.subnet_ids {
let mut array_208 = object.key("SubnetIds").start_array();
for item_209 in var_207 {
{
array_208.value().string(item_209.as_str());
}
}
array_208.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_user_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateUserInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_210) = &input.user_name {
object.key("UserName").string(var_210.as_str());
}
if let Some(var_211) = &input.authentication_mode {
#[allow(unused_mut)]
let mut object_212 = object.key("AuthenticationMode").start_object();
crate::json_ser::serialize_structure_crate_model_authentication_mode(
&mut object_212,
var_211,
)?;
object_212.finish();
}
if let Some(var_213) = &input.access_string {
object.key("AccessString").string(var_213.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_service_update_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServiceUpdateRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_214) = &input.service_update_name_to_apply {
object
.key("ServiceUpdateNameToApply")
.string(var_214.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_215) = &input.key {
object.key("Key").string(var_215.as_str());
}
if let Some(var_216) = &input.value {
object.key("Value").string(var_216.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_authentication_mode(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AuthenticationMode,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_217) = &input.r#type {
object.key("Type").string(var_217.as_str());
}
if let Some(var_218) = &input.passwords {
let mut array_219 = object.key("Passwords").start_array();
for item_220 in var_218 {
{
array_219.value().string(item_220.as_str());
}
}
array_219.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Filter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_221) = &input.name {
object.key("Name").string(var_221.as_str());
}
if let Some(var_222) = &input.values {
let mut array_223 = object.key("Values").start_array();
for item_224 in var_222 {
{
array_223.value().string(item_224.as_str());
}
}
array_223.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_replica_configuration_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReplicaConfigurationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.replica_count != 0 {
object.key("ReplicaCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.replica_count).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_shard_configuration_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ShardConfigurationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.shard_count != 0 {
object.key("ShardCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.shard_count).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_parameter_name_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParameterNameValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_225) = &input.parameter_name {
object.key("ParameterName").string(var_225.as_str());
}
if let Some(var_226) = &input.parameter_value {
object.key("ParameterValue").string(var_226.as_str());
}
Ok(())
}