pub fn serialize_structure_crate_input_batch_execute_statement_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchExecuteStatementInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.statements {
let mut array_2 = object.key("Statements").start_array();
for item_3 in var_1 {
{
#[allow(unused_mut)]
let mut object_4 = array_2.value().start_object();
crate::json_ser::serialize_structure_crate_model_batch_statement_request(
&mut object_4,
item_3,
)?;
object_4.finish();
}
}
array_2.finish();
}
if let Some(var_5) = &input.return_consumed_capacity {
object.key("ReturnConsumedCapacity").string(var_5.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_get_item_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetItemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_6) = &input.request_items {
#[allow(unused_mut)]
let mut object_7 = object.key("RequestItems").start_object();
for (key_8, value_9) in var_6 {
{
#[allow(unused_mut)]
let mut object_10 = object_7.key(key_8.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_keys_and_attributes(
&mut object_10,
value_9,
)?;
object_10.finish();
}
}
object_7.finish();
}
if let Some(var_11) = &input.return_consumed_capacity {
object.key("ReturnConsumedCapacity").string(var_11.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_write_item_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchWriteItemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_12) = &input.request_items {
#[allow(unused_mut)]
let mut object_13 = object.key("RequestItems").start_object();
for (key_14, value_15) in var_12 {
{
let mut array_16 = object_13.key(key_14.as_str()).start_array();
for item_17 in value_15 {
{
#[allow(unused_mut)]
let mut object_18 = array_16.value().start_object();
crate::json_ser::serialize_structure_crate_model_write_request(
&mut object_18,
item_17,
)?;
object_18.finish();
}
}
array_16.finish();
}
}
object_13.finish();
}
if let Some(var_19) = &input.return_consumed_capacity {
object.key("ReturnConsumedCapacity").string(var_19.as_str());
}
if let Some(var_20) = &input.return_item_collection_metrics {
object
.key("ReturnItemCollectionMetrics")
.string(var_20.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_backup_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBackupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_21) = &input.table_name {
object.key("TableName").string(var_21.as_str());
}
if let Some(var_22) = &input.backup_name {
object.key("BackupName").string(var_22.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_global_table_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateGlobalTableInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_23) = &input.global_table_name {
object.key("GlobalTableName").string(var_23.as_str());
}
if let Some(var_24) = &input.replication_group {
let mut array_25 = object.key("ReplicationGroup").start_array();
for item_26 in var_24 {
{
#[allow(unused_mut)]
let mut object_27 = array_25.value().start_object();
crate::json_ser::serialize_structure_crate_model_replica(&mut object_27, item_26)?;
object_27.finish();
}
}
array_25.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_table_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTableInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_28) = &input.attribute_definitions {
let mut array_29 = object.key("AttributeDefinitions").start_array();
for item_30 in var_28 {
{
#[allow(unused_mut)]
let mut object_31 = array_29.value().start_object();
crate::json_ser::serialize_structure_crate_model_attribute_definition(
&mut object_31,
item_30,
)?;
object_31.finish();
}
}
array_29.finish();
}
if let Some(var_32) = &input.table_name {
object.key("TableName").string(var_32.as_str());
}
if let Some(var_33) = &input.key_schema {
let mut array_34 = object.key("KeySchema").start_array();
for item_35 in var_33 {
{
#[allow(unused_mut)]
let mut object_36 = array_34.value().start_object();
crate::json_ser::serialize_structure_crate_model_key_schema_element(
&mut object_36,
item_35,
)?;
object_36.finish();
}
}
array_34.finish();
}
if let Some(var_37) = &input.local_secondary_indexes {
let mut array_38 = object.key("LocalSecondaryIndexes").start_array();
for item_39 in var_37 {
{
#[allow(unused_mut)]
let mut object_40 = array_38.value().start_object();
crate::json_ser::serialize_structure_crate_model_local_secondary_index(
&mut object_40,
item_39,
)?;
object_40.finish();
}
}
array_38.finish();
}
if let Some(var_41) = &input.global_secondary_indexes {
let mut array_42 = object.key("GlobalSecondaryIndexes").start_array();
for item_43 in var_41 {
{
#[allow(unused_mut)]
let mut object_44 = array_42.value().start_object();
crate::json_ser::serialize_structure_crate_model_global_secondary_index(
&mut object_44,
item_43,
)?;
object_44.finish();
}
}
array_42.finish();
}
if let Some(var_45) = &input.billing_mode {
object.key("BillingMode").string(var_45.as_str());
}
if let Some(var_46) = &input.provisioned_throughput {
#[allow(unused_mut)]
let mut object_47 = object.key("ProvisionedThroughput").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput(
&mut object_47,
var_46,
)?;
object_47.finish();
}
if let Some(var_48) = &input.stream_specification {
#[allow(unused_mut)]
let mut object_49 = object.key("StreamSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_stream_specification(
&mut object_49,
var_48,
)?;
object_49.finish();
}
if let Some(var_50) = &input.sse_specification {
#[allow(unused_mut)]
let mut object_51 = object.key("SSESpecification").start_object();
crate::json_ser::serialize_structure_crate_model_sse_specification(&mut object_51, var_50)?;
object_51.finish();
}
if let Some(var_52) = &input.tags {
let mut array_53 = object.key("Tags").start_array();
for item_54 in var_52 {
{
#[allow(unused_mut)]
let mut object_55 = array_53.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_55, item_54)?;
object_55.finish();
}
}
array_53.finish();
}
if let Some(var_56) = &input.table_class {
object.key("TableClass").string(var_56.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_backup_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteBackupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_57) = &input.backup_arn {
object.key("BackupArn").string(var_57.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_item_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteItemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_58) = &input.table_name {
object.key("TableName").string(var_58.as_str());
}
if let Some(var_59) = &input.key {
#[allow(unused_mut)]
let mut object_60 = object.key("Key").start_object();
for (key_61, value_62) in var_59 {
{
#[allow(unused_mut)]
let mut object_63 = object_60.key(key_61.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_63,
value_62,
)?;
object_63.finish();
}
}
object_60.finish();
}
if let Some(var_64) = &input.expected {
#[allow(unused_mut)]
let mut object_65 = object.key("Expected").start_object();
for (key_66, value_67) in var_64 {
{
#[allow(unused_mut)]
let mut object_68 = object_65.key(key_66.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_expected_attribute_value(
&mut object_68,
value_67,
)?;
object_68.finish();
}
}
object_65.finish();
}
if let Some(var_69) = &input.conditional_operator {
object.key("ConditionalOperator").string(var_69.as_str());
}
if let Some(var_70) = &input.return_values {
object.key("ReturnValues").string(var_70.as_str());
}
if let Some(var_71) = &input.return_consumed_capacity {
object.key("ReturnConsumedCapacity").string(var_71.as_str());
}
if let Some(var_72) = &input.return_item_collection_metrics {
object
.key("ReturnItemCollectionMetrics")
.string(var_72.as_str());
}
if let Some(var_73) = &input.condition_expression {
object.key("ConditionExpression").string(var_73.as_str());
}
if let Some(var_74) = &input.expression_attribute_names {
#[allow(unused_mut)]
let mut object_75 = object.key("ExpressionAttributeNames").start_object();
for (key_76, value_77) in var_74 {
{
object_75.key(key_76.as_str()).string(value_77.as_str());
}
}
object_75.finish();
}
if let Some(var_78) = &input.expression_attribute_values {
#[allow(unused_mut)]
let mut object_79 = object.key("ExpressionAttributeValues").start_object();
for (key_80, value_81) in var_78 {
{
#[allow(unused_mut)]
let mut object_82 = object_79.key(key_80.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_82,
value_81,
)?;
object_82.finish();
}
}
object_79.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_table_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteTableInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_83) = &input.table_name {
object.key("TableName").string(var_83.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_backup_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeBackupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_84) = &input.backup_arn {
object.key("BackupArn").string(var_84.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_continuous_backups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeContinuousBackupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.table_name {
object.key("TableName").string(var_85.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_contributor_insights_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeContributorInsightsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_86) = &input.table_name {
object.key("TableName").string(var_86.as_str());
}
if let Some(var_87) = &input.index_name {
object.key("IndexName").string(var_87.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_export_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeExportInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_88) = &input.export_arn {
object.key("ExportArn").string(var_88.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_global_table_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeGlobalTableInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.global_table_name {
object.key("GlobalTableName").string(var_89.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_global_table_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeGlobalTableSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_90) = &input.global_table_name {
object.key("GlobalTableName").string(var_90.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_import_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeImportInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_91) = &input.import_arn {
object.key("ImportArn").string(var_91.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_kinesis_streaming_destination_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeKinesisStreamingDestinationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_92) = &input.table_name {
object.key("TableName").string(var_92.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_table_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTableInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.table_name {
object.key("TableName").string(var_93.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_table_replica_auto_scaling_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTableReplicaAutoScalingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_94) = &input.table_name {
object.key("TableName").string(var_94.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_time_to_live_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTimeToLiveInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_95) = &input.table_name {
object.key("TableName").string(var_95.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disable_kinesis_streaming_destination_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisableKinesisStreamingDestinationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_96) = &input.table_name {
object.key("TableName").string(var_96.as_str());
}
if let Some(var_97) = &input.stream_arn {
object.key("StreamArn").string(var_97.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_enable_kinesis_streaming_destination_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::EnableKinesisStreamingDestinationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_98) = &input.table_name {
object.key("TableName").string(var_98.as_str());
}
if let Some(var_99) = &input.stream_arn {
object.key("StreamArn").string(var_99.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_execute_statement_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ExecuteStatementInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_100) = &input.statement {
object.key("Statement").string(var_100.as_str());
}
if let Some(var_101) = &input.parameters {
let mut array_102 = object.key("Parameters").start_array();
for item_103 in var_101 {
{
#[allow(unused_mut)]
let mut object_104 = array_102.value().start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_104,
item_103,
)?;
object_104.finish();
}
}
array_102.finish();
}
if let Some(var_105) = &input.consistent_read {
object.key("ConsistentRead").boolean(*var_105);
}
if let Some(var_106) = &input.next_token {
object.key("NextToken").string(var_106.as_str());
}
if let Some(var_107) = &input.return_consumed_capacity {
object
.key("ReturnConsumedCapacity")
.string(var_107.as_str());
}
if let Some(var_108) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_108).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_execute_transaction_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ExecuteTransactionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_109) = &input.transact_statements {
let mut array_110 = object.key("TransactStatements").start_array();
for item_111 in var_109 {
{
#[allow(unused_mut)]
let mut object_112 = array_110.value().start_object();
crate::json_ser::serialize_structure_crate_model_parameterized_statement(
&mut object_112,
item_111,
)?;
object_112.finish();
}
}
array_110.finish();
}
if let Some(var_113) = &input.client_request_token {
object.key("ClientRequestToken").string(var_113.as_str());
}
if let Some(var_114) = &input.return_consumed_capacity {
object
.key("ReturnConsumedCapacity")
.string(var_114.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_export_table_to_point_in_time_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ExportTableToPointInTimeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_115) = &input.table_arn {
object.key("TableArn").string(var_115.as_str());
}
if let Some(var_116) = &input.export_time {
object
.key("ExportTime")
.date_time(var_116, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_117) = &input.client_token {
object.key("ClientToken").string(var_117.as_str());
}
if let Some(var_118) = &input.s3_bucket {
object.key("S3Bucket").string(var_118.as_str());
}
if let Some(var_119) = &input.s3_bucket_owner {
object.key("S3BucketOwner").string(var_119.as_str());
}
if let Some(var_120) = &input.s3_prefix {
object.key("S3Prefix").string(var_120.as_str());
}
if let Some(var_121) = &input.s3_sse_algorithm {
object.key("S3SseAlgorithm").string(var_121.as_str());
}
if let Some(var_122) = &input.s3_sse_kms_key_id {
object.key("S3SseKmsKeyId").string(var_122.as_str());
}
if let Some(var_123) = &input.export_format {
object.key("ExportFormat").string(var_123.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_item_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetItemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_124) = &input.table_name {
object.key("TableName").string(var_124.as_str());
}
if let Some(var_125) = &input.key {
#[allow(unused_mut)]
let mut object_126 = object.key("Key").start_object();
for (key_127, value_128) in var_125 {
{
#[allow(unused_mut)]
let mut object_129 = object_126.key(key_127.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_129,
value_128,
)?;
object_129.finish();
}
}
object_126.finish();
}
if let Some(var_130) = &input.attributes_to_get {
let mut array_131 = object.key("AttributesToGet").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.consistent_read {
object.key("ConsistentRead").boolean(*var_133);
}
if let Some(var_134) = &input.return_consumed_capacity {
object
.key("ReturnConsumedCapacity")
.string(var_134.as_str());
}
if let Some(var_135) = &input.projection_expression {
object.key("ProjectionExpression").string(var_135.as_str());
}
if let Some(var_136) = &input.expression_attribute_names {
#[allow(unused_mut)]
let mut object_137 = object.key("ExpressionAttributeNames").start_object();
for (key_138, value_139) in var_136 {
{
object_137.key(key_138.as_str()).string(value_139.as_str());
}
}
object_137.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_import_table_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ImportTableInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_140) = &input.client_token {
object.key("ClientToken").string(var_140.as_str());
}
if let Some(var_141) = &input.s3_bucket_source {
#[allow(unused_mut)]
let mut object_142 = object.key("S3BucketSource").start_object();
crate::json_ser::serialize_structure_crate_model_s3_bucket_source(
&mut object_142,
var_141,
)?;
object_142.finish();
}
if let Some(var_143) = &input.input_format {
object.key("InputFormat").string(var_143.as_str());
}
if let Some(var_144) = &input.input_format_options {
#[allow(unused_mut)]
let mut object_145 = object.key("InputFormatOptions").start_object();
crate::json_ser::serialize_structure_crate_model_input_format_options(
&mut object_145,
var_144,
)?;
object_145.finish();
}
if let Some(var_146) = &input.input_compression_type {
object.key("InputCompressionType").string(var_146.as_str());
}
if let Some(var_147) = &input.table_creation_parameters {
#[allow(unused_mut)]
let mut object_148 = object.key("TableCreationParameters").start_object();
crate::json_ser::serialize_structure_crate_model_table_creation_parameters(
&mut object_148,
var_147,
)?;
object_148.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_backups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListBackupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_149) = &input.table_name {
object.key("TableName").string(var_149.as_str());
}
if let Some(var_150) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_150).into()),
);
}
if let Some(var_151) = &input.time_range_lower_bound {
object
.key("TimeRangeLowerBound")
.date_time(var_151, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_152) = &input.time_range_upper_bound {
object
.key("TimeRangeUpperBound")
.date_time(var_152, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_153) = &input.exclusive_start_backup_arn {
object
.key("ExclusiveStartBackupArn")
.string(var_153.as_str());
}
if let Some(var_154) = &input.backup_type {
object.key("BackupType").string(var_154.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_contributor_insights_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListContributorInsightsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_155) = &input.table_name {
object.key("TableName").string(var_155.as_str());
}
if let Some(var_156) = &input.next_token {
object.key("NextToken").string(var_156.as_str());
}
if input.max_results != 0 {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_exports_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListExportsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_157) = &input.table_arn {
object.key("TableArn").string(var_157.as_str());
}
if let Some(var_158) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_158).into()),
);
}
if let Some(var_159) = &input.next_token {
object.key("NextToken").string(var_159.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_global_tables_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListGlobalTablesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_160) = &input.exclusive_start_global_table_name {
object
.key("ExclusiveStartGlobalTableName")
.string(var_160.as_str());
}
if let Some(var_161) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_161).into()),
);
}
if let Some(var_162) = &input.region_name {
object.key("RegionName").string(var_162.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_imports_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListImportsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_163) = &input.table_arn {
object.key("TableArn").string(var_163.as_str());
}
if let Some(var_164) = &input.page_size {
object.key("PageSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_164).into()),
);
}
if let Some(var_165) = &input.next_token {
object.key("NextToken").string(var_165.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tables_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTablesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_166) = &input.exclusive_start_table_name {
object
.key("ExclusiveStartTableName")
.string(var_166.as_str());
}
if let Some(var_167) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_167).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tags_of_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTagsOfResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_168) = &input.resource_arn {
object.key("ResourceArn").string(var_168.as_str());
}
if let Some(var_169) = &input.next_token {
object.key("NextToken").string(var_169.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_item_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutItemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_170) = &input.table_name {
object.key("TableName").string(var_170.as_str());
}
if let Some(var_171) = &input.item {
#[allow(unused_mut)]
let mut object_172 = object.key("Item").start_object();
for (key_173, value_174) in var_171 {
{
#[allow(unused_mut)]
let mut object_175 = object_172.key(key_173.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_175,
value_174,
)?;
object_175.finish();
}
}
object_172.finish();
}
if let Some(var_176) = &input.expected {
#[allow(unused_mut)]
let mut object_177 = object.key("Expected").start_object();
for (key_178, value_179) in var_176 {
{
#[allow(unused_mut)]
let mut object_180 = object_177.key(key_178.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_expected_attribute_value(
&mut object_180,
value_179,
)?;
object_180.finish();
}
}
object_177.finish();
}
if let Some(var_181) = &input.return_values {
object.key("ReturnValues").string(var_181.as_str());
}
if let Some(var_182) = &input.return_consumed_capacity {
object
.key("ReturnConsumedCapacity")
.string(var_182.as_str());
}
if let Some(var_183) = &input.return_item_collection_metrics {
object
.key("ReturnItemCollectionMetrics")
.string(var_183.as_str());
}
if let Some(var_184) = &input.conditional_operator {
object.key("ConditionalOperator").string(var_184.as_str());
}
if let Some(var_185) = &input.condition_expression {
object.key("ConditionExpression").string(var_185.as_str());
}
if let Some(var_186) = &input.expression_attribute_names {
#[allow(unused_mut)]
let mut object_187 = object.key("ExpressionAttributeNames").start_object();
for (key_188, value_189) in var_186 {
{
object_187.key(key_188.as_str()).string(value_189.as_str());
}
}
object_187.finish();
}
if let Some(var_190) = &input.expression_attribute_values {
#[allow(unused_mut)]
let mut object_191 = object.key("ExpressionAttributeValues").start_object();
for (key_192, value_193) in var_190 {
{
#[allow(unused_mut)]
let mut object_194 = object_191.key(key_192.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_194,
value_193,
)?;
object_194.finish();
}
}
object_191.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_query_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::QueryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_195) = &input.table_name {
object.key("TableName").string(var_195.as_str());
}
if let Some(var_196) = &input.index_name {
object.key("IndexName").string(var_196.as_str());
}
if let Some(var_197) = &input.select {
object.key("Select").string(var_197.as_str());
}
if let Some(var_198) = &input.attributes_to_get {
let mut array_199 = object.key("AttributesToGet").start_array();
for item_200 in var_198 {
{
array_199.value().string(item_200.as_str());
}
}
array_199.finish();
}
if let Some(var_201) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_201).into()),
);
}
if let Some(var_202) = &input.consistent_read {
object.key("ConsistentRead").boolean(*var_202);
}
if let Some(var_203) = &input.key_conditions {
#[allow(unused_mut)]
let mut object_204 = object.key("KeyConditions").start_object();
for (key_205, value_206) in var_203 {
{
#[allow(unused_mut)]
let mut object_207 = object_204.key(key_205.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_condition(
&mut object_207,
value_206,
)?;
object_207.finish();
}
}
object_204.finish();
}
if let Some(var_208) = &input.query_filter {
#[allow(unused_mut)]
let mut object_209 = object.key("QueryFilter").start_object();
for (key_210, value_211) in var_208 {
{
#[allow(unused_mut)]
let mut object_212 = object_209.key(key_210.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_condition(
&mut object_212,
value_211,
)?;
object_212.finish();
}
}
object_209.finish();
}
if let Some(var_213) = &input.conditional_operator {
object.key("ConditionalOperator").string(var_213.as_str());
}
if let Some(var_214) = &input.scan_index_forward {
object.key("ScanIndexForward").boolean(*var_214);
}
if let Some(var_215) = &input.exclusive_start_key {
#[allow(unused_mut)]
let mut object_216 = object.key("ExclusiveStartKey").start_object();
for (key_217, value_218) in var_215 {
{
#[allow(unused_mut)]
let mut object_219 = object_216.key(key_217.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_219,
value_218,
)?;
object_219.finish();
}
}
object_216.finish();
}
if let Some(var_220) = &input.return_consumed_capacity {
object
.key("ReturnConsumedCapacity")
.string(var_220.as_str());
}
if let Some(var_221) = &input.projection_expression {
object.key("ProjectionExpression").string(var_221.as_str());
}
if let Some(var_222) = &input.filter_expression {
object.key("FilterExpression").string(var_222.as_str());
}
if let Some(var_223) = &input.key_condition_expression {
object
.key("KeyConditionExpression")
.string(var_223.as_str());
}
if let Some(var_224) = &input.expression_attribute_names {
#[allow(unused_mut)]
let mut object_225 = object.key("ExpressionAttributeNames").start_object();
for (key_226, value_227) in var_224 {
{
object_225.key(key_226.as_str()).string(value_227.as_str());
}
}
object_225.finish();
}
if let Some(var_228) = &input.expression_attribute_values {
#[allow(unused_mut)]
let mut object_229 = object.key("ExpressionAttributeValues").start_object();
for (key_230, value_231) in var_228 {
{
#[allow(unused_mut)]
let mut object_232 = object_229.key(key_230.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_232,
value_231,
)?;
object_232.finish();
}
}
object_229.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_restore_table_from_backup_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RestoreTableFromBackupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_233) = &input.target_table_name {
object.key("TargetTableName").string(var_233.as_str());
}
if let Some(var_234) = &input.backup_arn {
object.key("BackupArn").string(var_234.as_str());
}
if let Some(var_235) = &input.billing_mode_override {
object.key("BillingModeOverride").string(var_235.as_str());
}
if let Some(var_236) = &input.global_secondary_index_override {
let mut array_237 = object.key("GlobalSecondaryIndexOverride").start_array();
for item_238 in var_236 {
{
#[allow(unused_mut)]
let mut object_239 = array_237.value().start_object();
crate::json_ser::serialize_structure_crate_model_global_secondary_index(
&mut object_239,
item_238,
)?;
object_239.finish();
}
}
array_237.finish();
}
if let Some(var_240) = &input.local_secondary_index_override {
let mut array_241 = object.key("LocalSecondaryIndexOverride").start_array();
for item_242 in var_240 {
{
#[allow(unused_mut)]
let mut object_243 = array_241.value().start_object();
crate::json_ser::serialize_structure_crate_model_local_secondary_index(
&mut object_243,
item_242,
)?;
object_243.finish();
}
}
array_241.finish();
}
if let Some(var_244) = &input.provisioned_throughput_override {
#[allow(unused_mut)]
let mut object_245 = object.key("ProvisionedThroughputOverride").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput(
&mut object_245,
var_244,
)?;
object_245.finish();
}
if let Some(var_246) = &input.sse_specification_override {
#[allow(unused_mut)]
let mut object_247 = object.key("SSESpecificationOverride").start_object();
crate::json_ser::serialize_structure_crate_model_sse_specification(
&mut object_247,
var_246,
)?;
object_247.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_restore_table_to_point_in_time_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RestoreTableToPointInTimeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_248) = &input.source_table_arn {
object.key("SourceTableArn").string(var_248.as_str());
}
if let Some(var_249) = &input.source_table_name {
object.key("SourceTableName").string(var_249.as_str());
}
if let Some(var_250) = &input.target_table_name {
object.key("TargetTableName").string(var_250.as_str());
}
if let Some(var_251) = &input.use_latest_restorable_time {
object.key("UseLatestRestorableTime").boolean(*var_251);
}
if let Some(var_252) = &input.restore_date_time {
object
.key("RestoreDateTime")
.date_time(var_252, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_253) = &input.billing_mode_override {
object.key("BillingModeOverride").string(var_253.as_str());
}
if let Some(var_254) = &input.global_secondary_index_override {
let mut array_255 = object.key("GlobalSecondaryIndexOverride").start_array();
for item_256 in var_254 {
{
#[allow(unused_mut)]
let mut object_257 = array_255.value().start_object();
crate::json_ser::serialize_structure_crate_model_global_secondary_index(
&mut object_257,
item_256,
)?;
object_257.finish();
}
}
array_255.finish();
}
if let Some(var_258) = &input.local_secondary_index_override {
let mut array_259 = object.key("LocalSecondaryIndexOverride").start_array();
for item_260 in var_258 {
{
#[allow(unused_mut)]
let mut object_261 = array_259.value().start_object();
crate::json_ser::serialize_structure_crate_model_local_secondary_index(
&mut object_261,
item_260,
)?;
object_261.finish();
}
}
array_259.finish();
}
if let Some(var_262) = &input.provisioned_throughput_override {
#[allow(unused_mut)]
let mut object_263 = object.key("ProvisionedThroughputOverride").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput(
&mut object_263,
var_262,
)?;
object_263.finish();
}
if let Some(var_264) = &input.sse_specification_override {
#[allow(unused_mut)]
let mut object_265 = object.key("SSESpecificationOverride").start_object();
crate::json_ser::serialize_structure_crate_model_sse_specification(
&mut object_265,
var_264,
)?;
object_265.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_scan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ScanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_266) = &input.table_name {
object.key("TableName").string(var_266.as_str());
}
if let Some(var_267) = &input.index_name {
object.key("IndexName").string(var_267.as_str());
}
if let Some(var_268) = &input.attributes_to_get {
let mut array_269 = object.key("AttributesToGet").start_array();
for item_270 in var_268 {
{
array_269.value().string(item_270.as_str());
}
}
array_269.finish();
}
if let Some(var_271) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_271).into()),
);
}
if let Some(var_272) = &input.select {
object.key("Select").string(var_272.as_str());
}
if let Some(var_273) = &input.scan_filter {
#[allow(unused_mut)]
let mut object_274 = object.key("ScanFilter").start_object();
for (key_275, value_276) in var_273 {
{
#[allow(unused_mut)]
let mut object_277 = object_274.key(key_275.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_condition(
&mut object_277,
value_276,
)?;
object_277.finish();
}
}
object_274.finish();
}
if let Some(var_278) = &input.conditional_operator {
object.key("ConditionalOperator").string(var_278.as_str());
}
if let Some(var_279) = &input.exclusive_start_key {
#[allow(unused_mut)]
let mut object_280 = object.key("ExclusiveStartKey").start_object();
for (key_281, value_282) in var_279 {
{
#[allow(unused_mut)]
let mut object_283 = object_280.key(key_281.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_283,
value_282,
)?;
object_283.finish();
}
}
object_280.finish();
}
if let Some(var_284) = &input.return_consumed_capacity {
object
.key("ReturnConsumedCapacity")
.string(var_284.as_str());
}
if let Some(var_285) = &input.total_segments {
object.key("TotalSegments").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_285).into()),
);
}
if let Some(var_286) = &input.segment {
object.key("Segment").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_286).into()),
);
}
if let Some(var_287) = &input.projection_expression {
object.key("ProjectionExpression").string(var_287.as_str());
}
if let Some(var_288) = &input.filter_expression {
object.key("FilterExpression").string(var_288.as_str());
}
if let Some(var_289) = &input.expression_attribute_names {
#[allow(unused_mut)]
let mut object_290 = object.key("ExpressionAttributeNames").start_object();
for (key_291, value_292) in var_289 {
{
object_290.key(key_291.as_str()).string(value_292.as_str());
}
}
object_290.finish();
}
if let Some(var_293) = &input.expression_attribute_values {
#[allow(unused_mut)]
let mut object_294 = object.key("ExpressionAttributeValues").start_object();
for (key_295, value_296) in var_293 {
{
#[allow(unused_mut)]
let mut object_297 = object_294.key(key_295.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_297,
value_296,
)?;
object_297.finish();
}
}
object_294.finish();
}
if let Some(var_298) = &input.consistent_read {
object.key("ConsistentRead").boolean(*var_298);
}
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_299) = &input.resource_arn {
object.key("ResourceArn").string(var_299.as_str());
}
if let Some(var_300) = &input.tags {
let mut array_301 = object.key("Tags").start_array();
for item_302 in var_300 {
{
#[allow(unused_mut)]
let mut object_303 = array_301.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_303, item_302)?;
object_303.finish();
}
}
array_301.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_transact_get_items_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TransactGetItemsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_304) = &input.transact_items {
let mut array_305 = object.key("TransactItems").start_array();
for item_306 in var_304 {
{
#[allow(unused_mut)]
let mut object_307 = array_305.value().start_object();
crate::json_ser::serialize_structure_crate_model_transact_get_item(
&mut object_307,
item_306,
)?;
object_307.finish();
}
}
array_305.finish();
}
if let Some(var_308) = &input.return_consumed_capacity {
object
.key("ReturnConsumedCapacity")
.string(var_308.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_transact_write_items_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TransactWriteItemsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_309) = &input.transact_items {
let mut array_310 = object.key("TransactItems").start_array();
for item_311 in var_309 {
{
#[allow(unused_mut)]
let mut object_312 = array_310.value().start_object();
crate::json_ser::serialize_structure_crate_model_transact_write_item(
&mut object_312,
item_311,
)?;
object_312.finish();
}
}
array_310.finish();
}
if let Some(var_313) = &input.return_consumed_capacity {
object
.key("ReturnConsumedCapacity")
.string(var_313.as_str());
}
if let Some(var_314) = &input.return_item_collection_metrics {
object
.key("ReturnItemCollectionMetrics")
.string(var_314.as_str());
}
if let Some(var_315) = &input.client_request_token {
object.key("ClientRequestToken").string(var_315.as_str());
}
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_316) = &input.resource_arn {
object.key("ResourceArn").string(var_316.as_str());
}
if let Some(var_317) = &input.tag_keys {
let mut array_318 = object.key("TagKeys").start_array();
for item_319 in var_317 {
{
array_318.value().string(item_319.as_str());
}
}
array_318.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_continuous_backups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateContinuousBackupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_320) = &input.table_name {
object.key("TableName").string(var_320.as_str());
}
if let Some(var_321) = &input.point_in_time_recovery_specification {
#[allow(unused_mut)]
let mut object_322 = object
.key("PointInTimeRecoverySpecification")
.start_object();
crate::json_ser::serialize_structure_crate_model_point_in_time_recovery_specification(
&mut object_322,
var_321,
)?;
object_322.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_contributor_insights_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateContributorInsightsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_323) = &input.table_name {
object.key("TableName").string(var_323.as_str());
}
if let Some(var_324) = &input.index_name {
object.key("IndexName").string(var_324.as_str());
}
if let Some(var_325) = &input.contributor_insights_action {
object
.key("ContributorInsightsAction")
.string(var_325.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_global_table_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGlobalTableInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_326) = &input.global_table_name {
object.key("GlobalTableName").string(var_326.as_str());
}
if let Some(var_327) = &input.replica_updates {
let mut array_328 = object.key("ReplicaUpdates").start_array();
for item_329 in var_327 {
{
#[allow(unused_mut)]
let mut object_330 = array_328.value().start_object();
crate::json_ser::serialize_structure_crate_model_replica_update(
&mut object_330,
item_329,
)?;
object_330.finish();
}
}
array_328.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_global_table_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGlobalTableSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_331) = &input.global_table_name {
object.key("GlobalTableName").string(var_331.as_str());
}
if let Some(var_332) = &input.global_table_billing_mode {
object
.key("GlobalTableBillingMode")
.string(var_332.as_str());
}
if let Some(var_333) = &input.global_table_provisioned_write_capacity_units {
object
.key("GlobalTableProvisionedWriteCapacityUnits")
.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_333).into()),
);
}
if let Some(var_334) =
&input.global_table_provisioned_write_capacity_auto_scaling_settings_update
{
#[allow(unused_mut)]
let mut object_335 = object
.key("GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate")
.start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_settings_update(
&mut object_335,
var_334,
)?;
object_335.finish();
}
if let Some(var_336) = &input.global_table_global_secondary_index_settings_update {
let mut array_337 = object
.key("GlobalTableGlobalSecondaryIndexSettingsUpdate")
.start_array();
for item_338 in var_336 {
{
#[allow(unused_mut)]
let mut object_339 = array_337.value().start_object();
crate::json_ser::serialize_structure_crate_model_global_table_global_secondary_index_settings_update(&mut object_339, item_338)?;
object_339.finish();
}
}
array_337.finish();
}
if let Some(var_340) = &input.replica_settings_update {
let mut array_341 = object.key("ReplicaSettingsUpdate").start_array();
for item_342 in var_340 {
{
#[allow(unused_mut)]
let mut object_343 = array_341.value().start_object();
crate::json_ser::serialize_structure_crate_model_replica_settings_update(
&mut object_343,
item_342,
)?;
object_343.finish();
}
}
array_341.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_item_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateItemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_344) = &input.table_name {
object.key("TableName").string(var_344.as_str());
}
if let Some(var_345) = &input.key {
#[allow(unused_mut)]
let mut object_346 = object.key("Key").start_object();
for (key_347, value_348) in var_345 {
{
#[allow(unused_mut)]
let mut object_349 = object_346.key(key_347.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_349,
value_348,
)?;
object_349.finish();
}
}
object_346.finish();
}
if let Some(var_350) = &input.attribute_updates {
#[allow(unused_mut)]
let mut object_351 = object.key("AttributeUpdates").start_object();
for (key_352, value_353) in var_350 {
{
#[allow(unused_mut)]
let mut object_354 = object_351.key(key_352.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_attribute_value_update(
&mut object_354,
value_353,
)?;
object_354.finish();
}
}
object_351.finish();
}
if let Some(var_355) = &input.expected {
#[allow(unused_mut)]
let mut object_356 = object.key("Expected").start_object();
for (key_357, value_358) in var_355 {
{
#[allow(unused_mut)]
let mut object_359 = object_356.key(key_357.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_expected_attribute_value(
&mut object_359,
value_358,
)?;
object_359.finish();
}
}
object_356.finish();
}
if let Some(var_360) = &input.conditional_operator {
object.key("ConditionalOperator").string(var_360.as_str());
}
if let Some(var_361) = &input.return_values {
object.key("ReturnValues").string(var_361.as_str());
}
if let Some(var_362) = &input.return_consumed_capacity {
object
.key("ReturnConsumedCapacity")
.string(var_362.as_str());
}
if let Some(var_363) = &input.return_item_collection_metrics {
object
.key("ReturnItemCollectionMetrics")
.string(var_363.as_str());
}
if let Some(var_364) = &input.update_expression {
object.key("UpdateExpression").string(var_364.as_str());
}
if let Some(var_365) = &input.condition_expression {
object.key("ConditionExpression").string(var_365.as_str());
}
if let Some(var_366) = &input.expression_attribute_names {
#[allow(unused_mut)]
let mut object_367 = object.key("ExpressionAttributeNames").start_object();
for (key_368, value_369) in var_366 {
{
object_367.key(key_368.as_str()).string(value_369.as_str());
}
}
object_367.finish();
}
if let Some(var_370) = &input.expression_attribute_values {
#[allow(unused_mut)]
let mut object_371 = object.key("ExpressionAttributeValues").start_object();
for (key_372, value_373) in var_370 {
{
#[allow(unused_mut)]
let mut object_374 = object_371.key(key_372.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_374,
value_373,
)?;
object_374.finish();
}
}
object_371.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_table_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateTableInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_375) = &input.attribute_definitions {
let mut array_376 = object.key("AttributeDefinitions").start_array();
for item_377 in var_375 {
{
#[allow(unused_mut)]
let mut object_378 = array_376.value().start_object();
crate::json_ser::serialize_structure_crate_model_attribute_definition(
&mut object_378,
item_377,
)?;
object_378.finish();
}
}
array_376.finish();
}
if let Some(var_379) = &input.table_name {
object.key("TableName").string(var_379.as_str());
}
if let Some(var_380) = &input.billing_mode {
object.key("BillingMode").string(var_380.as_str());
}
if let Some(var_381) = &input.provisioned_throughput {
#[allow(unused_mut)]
let mut object_382 = object.key("ProvisionedThroughput").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput(
&mut object_382,
var_381,
)?;
object_382.finish();
}
if let Some(var_383) = &input.global_secondary_index_updates {
let mut array_384 = object.key("GlobalSecondaryIndexUpdates").start_array();
for item_385 in var_383 {
{
#[allow(unused_mut)]
let mut object_386 = array_384.value().start_object();
crate::json_ser::serialize_structure_crate_model_global_secondary_index_update(
&mut object_386,
item_385,
)?;
object_386.finish();
}
}
array_384.finish();
}
if let Some(var_387) = &input.stream_specification {
#[allow(unused_mut)]
let mut object_388 = object.key("StreamSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_stream_specification(
&mut object_388,
var_387,
)?;
object_388.finish();
}
if let Some(var_389) = &input.sse_specification {
#[allow(unused_mut)]
let mut object_390 = object.key("SSESpecification").start_object();
crate::json_ser::serialize_structure_crate_model_sse_specification(
&mut object_390,
var_389,
)?;
object_390.finish();
}
if let Some(var_391) = &input.replica_updates {
let mut array_392 = object.key("ReplicaUpdates").start_array();
for item_393 in var_391 {
{
#[allow(unused_mut)]
let mut object_394 = array_392.value().start_object();
crate::json_ser::serialize_structure_crate_model_replication_group_update(
&mut object_394,
item_393,
)?;
object_394.finish();
}
}
array_392.finish();
}
if let Some(var_395) = &input.table_class {
object.key("TableClass").string(var_395.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_table_replica_auto_scaling_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateTableReplicaAutoScalingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_396) = &input.global_secondary_index_updates {
let mut array_397 = object.key("GlobalSecondaryIndexUpdates").start_array();
for item_398 in var_396 {
{
#[allow(unused_mut)]
let mut object_399 = array_397.value().start_object();
crate::json_ser::serialize_structure_crate_model_global_secondary_index_auto_scaling_update(&mut object_399, item_398)?;
object_399.finish();
}
}
array_397.finish();
}
if let Some(var_400) = &input.table_name {
object.key("TableName").string(var_400.as_str());
}
if let Some(var_401) = &input.provisioned_write_capacity_auto_scaling_update {
#[allow(unused_mut)]
let mut object_402 = object
.key("ProvisionedWriteCapacityAutoScalingUpdate")
.start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_settings_update(
&mut object_402,
var_401,
)?;
object_402.finish();
}
if let Some(var_403) = &input.replica_updates {
let mut array_404 = object.key("ReplicaUpdates").start_array();
for item_405 in var_403 {
{
#[allow(unused_mut)]
let mut object_406 = array_404.value().start_object();
crate::json_ser::serialize_structure_crate_model_replica_auto_scaling_update(
&mut object_406,
item_405,
)?;
object_406.finish();
}
}
array_404.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_time_to_live_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateTimeToLiveInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_407) = &input.table_name {
object.key("TableName").string(var_407.as_str());
}
if let Some(var_408) = &input.time_to_live_specification {
#[allow(unused_mut)]
let mut object_409 = object.key("TimeToLiveSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_time_to_live_specification(
&mut object_409,
var_408,
)?;
object_409.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_batch_statement_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BatchStatementRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_410) = &input.statement {
object.key("Statement").string(var_410.as_str());
}
if let Some(var_411) = &input.parameters {
let mut array_412 = object.key("Parameters").start_array();
for item_413 in var_411 {
{
#[allow(unused_mut)]
let mut object_414 = array_412.value().start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_414,
item_413,
)?;
object_414.finish();
}
}
array_412.finish();
}
if let Some(var_415) = &input.consistent_read {
object.key("ConsistentRead").boolean(*var_415);
}
Ok(())
}
pub fn serialize_structure_crate_model_keys_and_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KeysAndAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_416) = &input.keys {
let mut array_417 = object.key("Keys").start_array();
for item_418 in var_416 {
{
#[allow(unused_mut)]
let mut object_419 = array_417.value().start_object();
for (key_420, value_421) in item_418 {
{
#[allow(unused_mut)]
let mut object_422 = object_419.key(key_420.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_422,
value_421,
)?;
object_422.finish();
}
}
object_419.finish();
}
}
array_417.finish();
}
if let Some(var_423) = &input.attributes_to_get {
let mut array_424 = object.key("AttributesToGet").start_array();
for item_425 in var_423 {
{
array_424.value().string(item_425.as_str());
}
}
array_424.finish();
}
if let Some(var_426) = &input.consistent_read {
object.key("ConsistentRead").boolean(*var_426);
}
if let Some(var_427) = &input.projection_expression {
object.key("ProjectionExpression").string(var_427.as_str());
}
if let Some(var_428) = &input.expression_attribute_names {
#[allow(unused_mut)]
let mut object_429 = object.key("ExpressionAttributeNames").start_object();
for (key_430, value_431) in var_428 {
{
object_429.key(key_430.as_str()).string(value_431.as_str());
}
}
object_429.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_write_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WriteRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_432) = &input.put_request {
#[allow(unused_mut)]
let mut object_433 = object.key("PutRequest").start_object();
crate::json_ser::serialize_structure_crate_model_put_request(&mut object_433, var_432)?;
object_433.finish();
}
if let Some(var_434) = &input.delete_request {
#[allow(unused_mut)]
let mut object_435 = object.key("DeleteRequest").start_object();
crate::json_ser::serialize_structure_crate_model_delete_request(&mut object_435, var_434)?;
object_435.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_replica(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Replica,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_436) = &input.region_name {
object.key("RegionName").string(var_436.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_attribute_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AttributeDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_437) = &input.attribute_name {
object.key("AttributeName").string(var_437.as_str());
}
if let Some(var_438) = &input.attribute_type {
object.key("AttributeType").string(var_438.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_key_schema_element(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KeySchemaElement,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_439) = &input.attribute_name {
object.key("AttributeName").string(var_439.as_str());
}
if let Some(var_440) = &input.key_type {
object.key("KeyType").string(var_440.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_local_secondary_index(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LocalSecondaryIndex,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_441) = &input.index_name {
object.key("IndexName").string(var_441.as_str());
}
if let Some(var_442) = &input.key_schema {
let mut array_443 = object.key("KeySchema").start_array();
for item_444 in var_442 {
{
#[allow(unused_mut)]
let mut object_445 = array_443.value().start_object();
crate::json_ser::serialize_structure_crate_model_key_schema_element(
&mut object_445,
item_444,
)?;
object_445.finish();
}
}
array_443.finish();
}
if let Some(var_446) = &input.projection {
#[allow(unused_mut)]
let mut object_447 = object.key("Projection").start_object();
crate::json_ser::serialize_structure_crate_model_projection(&mut object_447, var_446)?;
object_447.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_global_secondary_index(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GlobalSecondaryIndex,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_448) = &input.index_name {
object.key("IndexName").string(var_448.as_str());
}
if let Some(var_449) = &input.key_schema {
let mut array_450 = object.key("KeySchema").start_array();
for item_451 in var_449 {
{
#[allow(unused_mut)]
let mut object_452 = array_450.value().start_object();
crate::json_ser::serialize_structure_crate_model_key_schema_element(
&mut object_452,
item_451,
)?;
object_452.finish();
}
}
array_450.finish();
}
if let Some(var_453) = &input.projection {
#[allow(unused_mut)]
let mut object_454 = object.key("Projection").start_object();
crate::json_ser::serialize_structure_crate_model_projection(&mut object_454, var_453)?;
object_454.finish();
}
if let Some(var_455) = &input.provisioned_throughput {
#[allow(unused_mut)]
let mut object_456 = object.key("ProvisionedThroughput").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput(
&mut object_456,
var_455,
)?;
object_456.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_provisioned_throughput(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProvisionedThroughput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_457) = &input.read_capacity_units {
object.key("ReadCapacityUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_457).into()),
);
}
if let Some(var_458) = &input.write_capacity_units {
object.key("WriteCapacityUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_458).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_stream_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StreamSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_459) = &input.stream_enabled {
object.key("StreamEnabled").boolean(*var_459);
}
if let Some(var_460) = &input.stream_view_type {
object.key("StreamViewType").string(var_460.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sse_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SseSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_461) = &input.enabled {
object.key("Enabled").boolean(*var_461);
}
if let Some(var_462) = &input.sse_type {
object.key("SSEType").string(var_462.as_str());
}
if let Some(var_463) = &input.kms_master_key_id {
object.key("KMSMasterKeyId").string(var_463.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_464) = &input.key {
object.key("Key").string(var_464.as_str());
}
if let Some(var_465) = &input.value {
object.key("Value").string(var_465.as_str());
}
Ok(())
}
pub fn serialize_union_crate_model_attribute_value(
object_63: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AttributeValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::AttributeValue::S(inner) => {
object_63.key("S").string(inner.as_str());
}
crate::model::AttributeValue::N(inner) => {
object_63.key("N").string(inner.as_str());
}
crate::model::AttributeValue::B(inner) => {
object_63
.key("B")
.string_unchecked(&aws_smithy_types::base64::encode(inner));
}
crate::model::AttributeValue::Ss(inner) => {
let mut array_466 = object_63.key("SS").start_array();
for item_467 in inner {
{
array_466.value().string(item_467.as_str());
}
}
array_466.finish();
}
crate::model::AttributeValue::Ns(inner) => {
let mut array_468 = object_63.key("NS").start_array();
for item_469 in inner {
{
array_468.value().string(item_469.as_str());
}
}
array_468.finish();
}
crate::model::AttributeValue::Bs(inner) => {
let mut array_470 = object_63.key("BS").start_array();
for item_471 in inner {
{
array_470
.value()
.string_unchecked(&aws_smithy_types::base64::encode(item_471));
}
}
array_470.finish();
}
crate::model::AttributeValue::M(inner) => {
#[allow(unused_mut)]
let mut object_472 = object_63.key("M").start_object();
for (key_473, value_474) in inner {
{
#[allow(unused_mut)]
let mut object_475 = object_472.key(key_473.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_475,
value_474,
)?;
object_475.finish();
}
}
object_472.finish();
}
crate::model::AttributeValue::L(inner) => {
let mut array_476 = object_63.key("L").start_array();
for item_477 in inner {
{
#[allow(unused_mut)]
let mut object_478 = array_476.value().start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_478,
item_477,
)?;
object_478.finish();
}
}
array_476.finish();
}
crate::model::AttributeValue::Null(inner) => {
object_63.key("NULL").boolean(*inner);
}
crate::model::AttributeValue::Bool(inner) => {
object_63.key("BOOL").boolean(*inner);
}
crate::model::AttributeValue::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"AttributeValue",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_expected_attribute_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExpectedAttributeValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_479) = &input.value {
#[allow(unused_mut)]
let mut object_480 = object.key("Value").start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(&mut object_480, var_479)?;
object_480.finish();
}
if let Some(var_481) = &input.exists {
object.key("Exists").boolean(*var_481);
}
if let Some(var_482) = &input.comparison_operator {
object.key("ComparisonOperator").string(var_482.as_str());
}
if let Some(var_483) = &input.attribute_value_list {
let mut array_484 = object.key("AttributeValueList").start_array();
for item_485 in var_483 {
{
#[allow(unused_mut)]
let mut object_486 = array_484.value().start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_486,
item_485,
)?;
object_486.finish();
}
}
array_484.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_parameterized_statement(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParameterizedStatement,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_487) = &input.statement {
object.key("Statement").string(var_487.as_str());
}
if let Some(var_488) = &input.parameters {
let mut array_489 = object.key("Parameters").start_array();
for item_490 in var_488 {
{
#[allow(unused_mut)]
let mut object_491 = array_489.value().start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_491,
item_490,
)?;
object_491.finish();
}
}
array_489.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_bucket_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3BucketSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_492) = &input.s3_bucket_owner {
object.key("S3BucketOwner").string(var_492.as_str());
}
if let Some(var_493) = &input.s3_bucket {
object.key("S3Bucket").string(var_493.as_str());
}
if let Some(var_494) = &input.s3_key_prefix {
object.key("S3KeyPrefix").string(var_494.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_input_format_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InputFormatOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_495) = &input.csv {
#[allow(unused_mut)]
let mut object_496 = object.key("Csv").start_object();
crate::json_ser::serialize_structure_crate_model_csv_options(&mut object_496, var_495)?;
object_496.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_table_creation_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableCreationParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_497) = &input.table_name {
object.key("TableName").string(var_497.as_str());
}
if let Some(var_498) = &input.attribute_definitions {
let mut array_499 = object.key("AttributeDefinitions").start_array();
for item_500 in var_498 {
{
#[allow(unused_mut)]
let mut object_501 = array_499.value().start_object();
crate::json_ser::serialize_structure_crate_model_attribute_definition(
&mut object_501,
item_500,
)?;
object_501.finish();
}
}
array_499.finish();
}
if let Some(var_502) = &input.key_schema {
let mut array_503 = object.key("KeySchema").start_array();
for item_504 in var_502 {
{
#[allow(unused_mut)]
let mut object_505 = array_503.value().start_object();
crate::json_ser::serialize_structure_crate_model_key_schema_element(
&mut object_505,
item_504,
)?;
object_505.finish();
}
}
array_503.finish();
}
if let Some(var_506) = &input.billing_mode {
object.key("BillingMode").string(var_506.as_str());
}
if let Some(var_507) = &input.provisioned_throughput {
#[allow(unused_mut)]
let mut object_508 = object.key("ProvisionedThroughput").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput(
&mut object_508,
var_507,
)?;
object_508.finish();
}
if let Some(var_509) = &input.sse_specification {
#[allow(unused_mut)]
let mut object_510 = object.key("SSESpecification").start_object();
crate::json_ser::serialize_structure_crate_model_sse_specification(
&mut object_510,
var_509,
)?;
object_510.finish();
}
if let Some(var_511) = &input.global_secondary_indexes {
let mut array_512 = object.key("GlobalSecondaryIndexes").start_array();
for item_513 in var_511 {
{
#[allow(unused_mut)]
let mut object_514 = array_512.value().start_object();
crate::json_ser::serialize_structure_crate_model_global_secondary_index(
&mut object_514,
item_513,
)?;
object_514.finish();
}
}
array_512.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Condition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_515) = &input.attribute_value_list {
let mut array_516 = object.key("AttributeValueList").start_array();
for item_517 in var_515 {
{
#[allow(unused_mut)]
let mut object_518 = array_516.value().start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_518,
item_517,
)?;
object_518.finish();
}
}
array_516.finish();
}
if let Some(var_519) = &input.comparison_operator {
object.key("ComparisonOperator").string(var_519.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_transact_get_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TransactGetItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_520) = &input.get {
#[allow(unused_mut)]
let mut object_521 = object.key("Get").start_object();
crate::json_ser::serialize_structure_crate_model_get(&mut object_521, var_520)?;
object_521.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_transact_write_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TransactWriteItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_522) = &input.condition_check {
#[allow(unused_mut)]
let mut object_523 = object.key("ConditionCheck").start_object();
crate::json_ser::serialize_structure_crate_model_condition_check(&mut object_523, var_522)?;
object_523.finish();
}
if let Some(var_524) = &input.put {
#[allow(unused_mut)]
let mut object_525 = object.key("Put").start_object();
crate::json_ser::serialize_structure_crate_model_put(&mut object_525, var_524)?;
object_525.finish();
}
if let Some(var_526) = &input.delete {
#[allow(unused_mut)]
let mut object_527 = object.key("Delete").start_object();
crate::json_ser::serialize_structure_crate_model_delete(&mut object_527, var_526)?;
object_527.finish();
}
if let Some(var_528) = &input.update {
#[allow(unused_mut)]
let mut object_529 = object.key("Update").start_object();
crate::json_ser::serialize_structure_crate_model_update(&mut object_529, var_528)?;
object_529.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_point_in_time_recovery_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PointInTimeRecoverySpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_530) = &input.point_in_time_recovery_enabled {
object.key("PointInTimeRecoveryEnabled").boolean(*var_530);
}
Ok(())
}
pub fn serialize_structure_crate_model_replica_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReplicaUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_531) = &input.create {
#[allow(unused_mut)]
let mut object_532 = object.key("Create").start_object();
crate::json_ser::serialize_structure_crate_model_create_replica_action(
&mut object_532,
var_531,
)?;
object_532.finish();
}
if let Some(var_533) = &input.delete {
#[allow(unused_mut)]
let mut object_534 = object.key("Delete").start_object();
crate::json_ser::serialize_structure_crate_model_delete_replica_action(
&mut object_534,
var_533,
)?;
object_534.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_scaling_settings_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoScalingSettingsUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_535) = &input.minimum_units {
object.key("MinimumUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_535).into()),
);
}
if let Some(var_536) = &input.maximum_units {
object.key("MaximumUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_536).into()),
);
}
if let Some(var_537) = &input.auto_scaling_disabled {
object.key("AutoScalingDisabled").boolean(*var_537);
}
if let Some(var_538) = &input.auto_scaling_role_arn {
object.key("AutoScalingRoleArn").string(var_538.as_str());
}
if let Some(var_539) = &input.scaling_policy_update {
#[allow(unused_mut)]
let mut object_540 = object.key("ScalingPolicyUpdate").start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_policy_update(
&mut object_540,
var_539,
)?;
object_540.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_global_table_global_secondary_index_settings_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GlobalTableGlobalSecondaryIndexSettingsUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_541) = &input.index_name {
object.key("IndexName").string(var_541.as_str());
}
if let Some(var_542) = &input.provisioned_write_capacity_units {
object.key("ProvisionedWriteCapacityUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_542).into()),
);
}
if let Some(var_543) = &input.provisioned_write_capacity_auto_scaling_settings_update {
#[allow(unused_mut)]
let mut object_544 = object
.key("ProvisionedWriteCapacityAutoScalingSettingsUpdate")
.start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_settings_update(
&mut object_544,
var_543,
)?;
object_544.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_replica_settings_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReplicaSettingsUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_545) = &input.region_name {
object.key("RegionName").string(var_545.as_str());
}
if let Some(var_546) = &input.replica_provisioned_read_capacity_units {
object.key("ReplicaProvisionedReadCapacityUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_546).into()),
);
}
if let Some(var_547) = &input.replica_provisioned_read_capacity_auto_scaling_settings_update {
#[allow(unused_mut)]
let mut object_548 = object
.key("ReplicaProvisionedReadCapacityAutoScalingSettingsUpdate")
.start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_settings_update(
&mut object_548,
var_547,
)?;
object_548.finish();
}
if let Some(var_549) = &input.replica_global_secondary_index_settings_update {
let mut array_550 = object
.key("ReplicaGlobalSecondaryIndexSettingsUpdate")
.start_array();
for item_551 in var_549 {
{
#[allow(unused_mut)]
let mut object_552 = array_550.value().start_object();
crate::json_ser::serialize_structure_crate_model_replica_global_secondary_index_settings_update(&mut object_552, item_551)?;
object_552.finish();
}
}
array_550.finish();
}
if let Some(var_553) = &input.replica_table_class {
object.key("ReplicaTableClass").string(var_553.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_attribute_value_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AttributeValueUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_554) = &input.value {
#[allow(unused_mut)]
let mut object_555 = object.key("Value").start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(&mut object_555, var_554)?;
object_555.finish();
}
if let Some(var_556) = &input.action {
object.key("Action").string(var_556.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_global_secondary_index_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GlobalSecondaryIndexUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_557) = &input.update {
#[allow(unused_mut)]
let mut object_558 = object.key("Update").start_object();
crate::json_ser::serialize_structure_crate_model_update_global_secondary_index_action(
&mut object_558,
var_557,
)?;
object_558.finish();
}
if let Some(var_559) = &input.create {
#[allow(unused_mut)]
let mut object_560 = object.key("Create").start_object();
crate::json_ser::serialize_structure_crate_model_create_global_secondary_index_action(
&mut object_560,
var_559,
)?;
object_560.finish();
}
if let Some(var_561) = &input.delete {
#[allow(unused_mut)]
let mut object_562 = object.key("Delete").start_object();
crate::json_ser::serialize_structure_crate_model_delete_global_secondary_index_action(
&mut object_562,
var_561,
)?;
object_562.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_replication_group_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReplicationGroupUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_563) = &input.create {
#[allow(unused_mut)]
let mut object_564 = object.key("Create").start_object();
crate::json_ser::serialize_structure_crate_model_create_replication_group_member_action(
&mut object_564,
var_563,
)?;
object_564.finish();
}
if let Some(var_565) = &input.update {
#[allow(unused_mut)]
let mut object_566 = object.key("Update").start_object();
crate::json_ser::serialize_structure_crate_model_update_replication_group_member_action(
&mut object_566,
var_565,
)?;
object_566.finish();
}
if let Some(var_567) = &input.delete {
#[allow(unused_mut)]
let mut object_568 = object.key("Delete").start_object();
crate::json_ser::serialize_structure_crate_model_delete_replication_group_member_action(
&mut object_568,
var_567,
)?;
object_568.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_global_secondary_index_auto_scaling_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GlobalSecondaryIndexAutoScalingUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_569) = &input.index_name {
object.key("IndexName").string(var_569.as_str());
}
if let Some(var_570) = &input.provisioned_write_capacity_auto_scaling_update {
#[allow(unused_mut)]
let mut object_571 = object
.key("ProvisionedWriteCapacityAutoScalingUpdate")
.start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_settings_update(
&mut object_571,
var_570,
)?;
object_571.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_replica_auto_scaling_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReplicaAutoScalingUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_572) = &input.region_name {
object.key("RegionName").string(var_572.as_str());
}
if let Some(var_573) = &input.replica_global_secondary_index_updates {
let mut array_574 = object
.key("ReplicaGlobalSecondaryIndexUpdates")
.start_array();
for item_575 in var_573 {
{
#[allow(unused_mut)]
let mut object_576 = array_574.value().start_object();
crate::json_ser::serialize_structure_crate_model_replica_global_secondary_index_auto_scaling_update(&mut object_576, item_575)?;
object_576.finish();
}
}
array_574.finish();
}
if let Some(var_577) = &input.replica_provisioned_read_capacity_auto_scaling_update {
#[allow(unused_mut)]
let mut object_578 = object
.key("ReplicaProvisionedReadCapacityAutoScalingUpdate")
.start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_settings_update(
&mut object_578,
var_577,
)?;
object_578.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_time_to_live_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimeToLiveSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_579) = &input.enabled {
object.key("Enabled").boolean(*var_579);
}
if let Some(var_580) = &input.attribute_name {
object.key("AttributeName").string(var_580.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_put_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PutRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_581) = &input.item {
#[allow(unused_mut)]
let mut object_582 = object.key("Item").start_object();
for (key_583, value_584) in var_581 {
{
#[allow(unused_mut)]
let mut object_585 = object_582.key(key_583.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_585,
value_584,
)?;
object_585.finish();
}
}
object_582.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_delete_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeleteRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_586) = &input.key {
#[allow(unused_mut)]
let mut object_587 = object.key("Key").start_object();
for (key_588, value_589) in var_586 {
{
#[allow(unused_mut)]
let mut object_590 = object_587.key(key_588.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_590,
value_589,
)?;
object_590.finish();
}
}
object_587.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_projection(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Projection,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_591) = &input.projection_type {
object.key("ProjectionType").string(var_591.as_str());
}
if let Some(var_592) = &input.non_key_attributes {
let mut array_593 = object.key("NonKeyAttributes").start_array();
for item_594 in var_592 {
{
array_593.value().string(item_594.as_str());
}
}
array_593.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_csv_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CsvOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_595) = &input.delimiter {
object.key("Delimiter").string(var_595.as_str());
}
if let Some(var_596) = &input.header_list {
let mut array_597 = object.key("HeaderList").start_array();
for item_598 in var_596 {
{
array_597.value().string(item_598.as_str());
}
}
array_597.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_get(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Get,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_599) = &input.key {
#[allow(unused_mut)]
let mut object_600 = object.key("Key").start_object();
for (key_601, value_602) in var_599 {
{
#[allow(unused_mut)]
let mut object_603 = object_600.key(key_601.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_603,
value_602,
)?;
object_603.finish();
}
}
object_600.finish();
}
if let Some(var_604) = &input.table_name {
object.key("TableName").string(var_604.as_str());
}
if let Some(var_605) = &input.projection_expression {
object.key("ProjectionExpression").string(var_605.as_str());
}
if let Some(var_606) = &input.expression_attribute_names {
#[allow(unused_mut)]
let mut object_607 = object.key("ExpressionAttributeNames").start_object();
for (key_608, value_609) in var_606 {
{
object_607.key(key_608.as_str()).string(value_609.as_str());
}
}
object_607.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_condition_check(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConditionCheck,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_610) = &input.key {
#[allow(unused_mut)]
let mut object_611 = object.key("Key").start_object();
for (key_612, value_613) in var_610 {
{
#[allow(unused_mut)]
let mut object_614 = object_611.key(key_612.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_614,
value_613,
)?;
object_614.finish();
}
}
object_611.finish();
}
if let Some(var_615) = &input.table_name {
object.key("TableName").string(var_615.as_str());
}
if let Some(var_616) = &input.condition_expression {
object.key("ConditionExpression").string(var_616.as_str());
}
if let Some(var_617) = &input.expression_attribute_names {
#[allow(unused_mut)]
let mut object_618 = object.key("ExpressionAttributeNames").start_object();
for (key_619, value_620) in var_617 {
{
object_618.key(key_619.as_str()).string(value_620.as_str());
}
}
object_618.finish();
}
if let Some(var_621) = &input.expression_attribute_values {
#[allow(unused_mut)]
let mut object_622 = object.key("ExpressionAttributeValues").start_object();
for (key_623, value_624) in var_621 {
{
#[allow(unused_mut)]
let mut object_625 = object_622.key(key_623.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_625,
value_624,
)?;
object_625.finish();
}
}
object_622.finish();
}
if let Some(var_626) = &input.return_values_on_condition_check_failure {
object
.key("ReturnValuesOnConditionCheckFailure")
.string(var_626.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_put(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Put,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_627) = &input.item {
#[allow(unused_mut)]
let mut object_628 = object.key("Item").start_object();
for (key_629, value_630) in var_627 {
{
#[allow(unused_mut)]
let mut object_631 = object_628.key(key_629.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_631,
value_630,
)?;
object_631.finish();
}
}
object_628.finish();
}
if let Some(var_632) = &input.table_name {
object.key("TableName").string(var_632.as_str());
}
if let Some(var_633) = &input.condition_expression {
object.key("ConditionExpression").string(var_633.as_str());
}
if let Some(var_634) = &input.expression_attribute_names {
#[allow(unused_mut)]
let mut object_635 = object.key("ExpressionAttributeNames").start_object();
for (key_636, value_637) in var_634 {
{
object_635.key(key_636.as_str()).string(value_637.as_str());
}
}
object_635.finish();
}
if let Some(var_638) = &input.expression_attribute_values {
#[allow(unused_mut)]
let mut object_639 = object.key("ExpressionAttributeValues").start_object();
for (key_640, value_641) in var_638 {
{
#[allow(unused_mut)]
let mut object_642 = object_639.key(key_640.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_642,
value_641,
)?;
object_642.finish();
}
}
object_639.finish();
}
if let Some(var_643) = &input.return_values_on_condition_check_failure {
object
.key("ReturnValuesOnConditionCheckFailure")
.string(var_643.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_delete(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Delete,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_644) = &input.key {
#[allow(unused_mut)]
let mut object_645 = object.key("Key").start_object();
for (key_646, value_647) in var_644 {
{
#[allow(unused_mut)]
let mut object_648 = object_645.key(key_646.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_648,
value_647,
)?;
object_648.finish();
}
}
object_645.finish();
}
if let Some(var_649) = &input.table_name {
object.key("TableName").string(var_649.as_str());
}
if let Some(var_650) = &input.condition_expression {
object.key("ConditionExpression").string(var_650.as_str());
}
if let Some(var_651) = &input.expression_attribute_names {
#[allow(unused_mut)]
let mut object_652 = object.key("ExpressionAttributeNames").start_object();
for (key_653, value_654) in var_651 {
{
object_652.key(key_653.as_str()).string(value_654.as_str());
}
}
object_652.finish();
}
if let Some(var_655) = &input.expression_attribute_values {
#[allow(unused_mut)]
let mut object_656 = object.key("ExpressionAttributeValues").start_object();
for (key_657, value_658) in var_655 {
{
#[allow(unused_mut)]
let mut object_659 = object_656.key(key_657.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_659,
value_658,
)?;
object_659.finish();
}
}
object_656.finish();
}
if let Some(var_660) = &input.return_values_on_condition_check_failure {
object
.key("ReturnValuesOnConditionCheckFailure")
.string(var_660.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Update,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_661) = &input.key {
#[allow(unused_mut)]
let mut object_662 = object.key("Key").start_object();
for (key_663, value_664) in var_661 {
{
#[allow(unused_mut)]
let mut object_665 = object_662.key(key_663.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_665,
value_664,
)?;
object_665.finish();
}
}
object_662.finish();
}
if let Some(var_666) = &input.update_expression {
object.key("UpdateExpression").string(var_666.as_str());
}
if let Some(var_667) = &input.table_name {
object.key("TableName").string(var_667.as_str());
}
if let Some(var_668) = &input.condition_expression {
object.key("ConditionExpression").string(var_668.as_str());
}
if let Some(var_669) = &input.expression_attribute_names {
#[allow(unused_mut)]
let mut object_670 = object.key("ExpressionAttributeNames").start_object();
for (key_671, value_672) in var_669 {
{
object_670.key(key_671.as_str()).string(value_672.as_str());
}
}
object_670.finish();
}
if let Some(var_673) = &input.expression_attribute_values {
#[allow(unused_mut)]
let mut object_674 = object.key("ExpressionAttributeValues").start_object();
for (key_675, value_676) in var_673 {
{
#[allow(unused_mut)]
let mut object_677 = object_674.key(key_675.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_677,
value_676,
)?;
object_677.finish();
}
}
object_674.finish();
}
if let Some(var_678) = &input.return_values_on_condition_check_failure {
object
.key("ReturnValuesOnConditionCheckFailure")
.string(var_678.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_create_replica_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateReplicaAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_679) = &input.region_name {
object.key("RegionName").string(var_679.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_delete_replica_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeleteReplicaAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_680) = &input.region_name {
object.key("RegionName").string(var_680.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_scaling_policy_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoScalingPolicyUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_681) = &input.policy_name {
object.key("PolicyName").string(var_681.as_str());
}
if let Some(var_682) = &input.target_tracking_scaling_policy_configuration {
#[allow(unused_mut)]
let mut object_683 = object
.key("TargetTrackingScalingPolicyConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_target_tracking_scaling_policy_configuration_update(&mut object_683, var_682)?;
object_683.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_replica_global_secondary_index_settings_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReplicaGlobalSecondaryIndexSettingsUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_684) = &input.index_name {
object.key("IndexName").string(var_684.as_str());
}
if let Some(var_685) = &input.provisioned_read_capacity_units {
object.key("ProvisionedReadCapacityUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_685).into()),
);
}
if let Some(var_686) = &input.provisioned_read_capacity_auto_scaling_settings_update {
#[allow(unused_mut)]
let mut object_687 = object
.key("ProvisionedReadCapacityAutoScalingSettingsUpdate")
.start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_settings_update(
&mut object_687,
var_686,
)?;
object_687.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_global_secondary_index_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateGlobalSecondaryIndexAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_688) = &input.index_name {
object.key("IndexName").string(var_688.as_str());
}
if let Some(var_689) = &input.provisioned_throughput {
#[allow(unused_mut)]
let mut object_690 = object.key("ProvisionedThroughput").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput(
&mut object_690,
var_689,
)?;
object_690.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_create_global_secondary_index_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateGlobalSecondaryIndexAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_691) = &input.index_name {
object.key("IndexName").string(var_691.as_str());
}
if let Some(var_692) = &input.key_schema {
let mut array_693 = object.key("KeySchema").start_array();
for item_694 in var_692 {
{
#[allow(unused_mut)]
let mut object_695 = array_693.value().start_object();
crate::json_ser::serialize_structure_crate_model_key_schema_element(
&mut object_695,
item_694,
)?;
object_695.finish();
}
}
array_693.finish();
}
if let Some(var_696) = &input.projection {
#[allow(unused_mut)]
let mut object_697 = object.key("Projection").start_object();
crate::json_ser::serialize_structure_crate_model_projection(&mut object_697, var_696)?;
object_697.finish();
}
if let Some(var_698) = &input.provisioned_throughput {
#[allow(unused_mut)]
let mut object_699 = object.key("ProvisionedThroughput").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput(
&mut object_699,
var_698,
)?;
object_699.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_delete_global_secondary_index_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeleteGlobalSecondaryIndexAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_700) = &input.index_name {
object.key("IndexName").string(var_700.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_create_replication_group_member_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateReplicationGroupMemberAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_701) = &input.region_name {
object.key("RegionName").string(var_701.as_str());
}
if let Some(var_702) = &input.kms_master_key_id {
object.key("KMSMasterKeyId").string(var_702.as_str());
}
if let Some(var_703) = &input.provisioned_throughput_override {
#[allow(unused_mut)]
let mut object_704 = object.key("ProvisionedThroughputOverride").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput_override(
&mut object_704,
var_703,
)?;
object_704.finish();
}
if let Some(var_705) = &input.global_secondary_indexes {
let mut array_706 = object.key("GlobalSecondaryIndexes").start_array();
for item_707 in var_705 {
{
#[allow(unused_mut)]
let mut object_708 = array_706.value().start_object();
crate::json_ser::serialize_structure_crate_model_replica_global_secondary_index(
&mut object_708,
item_707,
)?;
object_708.finish();
}
}
array_706.finish();
}
if let Some(var_709) = &input.table_class_override {
object.key("TableClassOverride").string(var_709.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update_replication_group_member_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateReplicationGroupMemberAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_710) = &input.region_name {
object.key("RegionName").string(var_710.as_str());
}
if let Some(var_711) = &input.kms_master_key_id {
object.key("KMSMasterKeyId").string(var_711.as_str());
}
if let Some(var_712) = &input.provisioned_throughput_override {
#[allow(unused_mut)]
let mut object_713 = object.key("ProvisionedThroughputOverride").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput_override(
&mut object_713,
var_712,
)?;
object_713.finish();
}
if let Some(var_714) = &input.global_secondary_indexes {
let mut array_715 = object.key("GlobalSecondaryIndexes").start_array();
for item_716 in var_714 {
{
#[allow(unused_mut)]
let mut object_717 = array_715.value().start_object();
crate::json_ser::serialize_structure_crate_model_replica_global_secondary_index(
&mut object_717,
item_716,
)?;
object_717.finish();
}
}
array_715.finish();
}
if let Some(var_718) = &input.table_class_override {
object.key("TableClassOverride").string(var_718.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_delete_replication_group_member_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeleteReplicationGroupMemberAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_719) = &input.region_name {
object.key("RegionName").string(var_719.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_replica_global_secondary_index_auto_scaling_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReplicaGlobalSecondaryIndexAutoScalingUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_720) = &input.index_name {
object.key("IndexName").string(var_720.as_str());
}
if let Some(var_721) = &input.provisioned_read_capacity_auto_scaling_update {
#[allow(unused_mut)]
let mut object_722 = object
.key("ProvisionedReadCapacityAutoScalingUpdate")
.start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_settings_update(
&mut object_722,
var_721,
)?;
object_722.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_scaling_target_tracking_scaling_policy_configuration_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoScalingTargetTrackingScalingPolicyConfigurationUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_723) = &input.disable_scale_in {
object.key("DisableScaleIn").boolean(*var_723);
}
if let Some(var_724) = &input.scale_in_cooldown {
object.key("ScaleInCooldown").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_724).into()),
);
}
if let Some(var_725) = &input.scale_out_cooldown {
object.key("ScaleOutCooldown").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_725).into()),
);
}
if let Some(var_726) = &input.target_value {
object.key("TargetValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_726).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_provisioned_throughput_override(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProvisionedThroughputOverride,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_727) = &input.read_capacity_units {
object.key("ReadCapacityUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_727).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_replica_global_secondary_index(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReplicaGlobalSecondaryIndex,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_728) = &input.index_name {
object.key("IndexName").string(var_728.as_str());
}
if let Some(var_729) = &input.provisioned_throughput_override {
#[allow(unused_mut)]
let mut object_730 = object.key("ProvisionedThroughputOverride").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput_override(
&mut object_730,
var_729,
)?;
object_730.finish();
}
Ok(())
}