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::SerializationError> {
if let Some(var_1) = &input.statements {
let mut array_2 = object.key("Statements").start_array();
for item_3 in var_1 {
{
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::SerializationError> {
if let Some(var_6) = &input.request_items {
let mut object_7 = object.key("RequestItems").start_object();
for (key_8, value_9) in var_6 {
{
let mut object_10 = object_7.key(key_8).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::SerializationError> {
if let Some(var_12) = &input.request_items {
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).start_array();
for item_17 in value_15 {
{
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::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::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 {
{
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::SerializationError> {
if let Some(var_28) = &input.attribute_definitions {
let mut array_29 = object.key("AttributeDefinitions").start_array();
for item_30 in var_28 {
{
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 {
{
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 {
{
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 {
{
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 {
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 {
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 {
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 {
{
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::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::SerializationError> {
if let Some(var_58) = &input.table_name {
object.key("TableName").string(var_58.as_str());
}
if let Some(var_59) = &input.key {
let mut object_60 = object.key("Key").start_object();
for (key_61, value_62) in var_59 {
{
let mut object_63 = object_60.key(key_61).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 {
let mut object_65 = object.key("Expected").start_object();
for (key_66, value_67) in var_64 {
{
let mut object_68 = object_65.key(key_66).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 {
let mut object_75 = object.key("ExpressionAttributeNames").start_object();
for (key_76, value_77) in var_74 {
{
object_75.key(key_76).string(value_77.as_str());
}
}
object_75.finish();
}
if let Some(var_78) = &input.expression_attribute_values {
let mut object_79 = object.key("ExpressionAttributeValues").start_object();
for (key_80, value_81) in var_78 {
{
let mut object_82 = object_79.key(key_80).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::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::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::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::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::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::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::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_kinesis_streaming_destination_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeKinesisStreamingDestinationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_91) = &input.table_name {
object.key("TableName").string(var_91.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::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_replica_auto_scaling_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTableReplicaAutoScalingInput,
) -> Result<(), aws_smithy_http::operation::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_time_to_live_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTimeToLiveInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_94) = &input.table_name {
object.key("TableName").string(var_94.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::SerializationError> {
if let Some(var_95) = &input.table_name {
object.key("TableName").string(var_95.as_str());
}
if let Some(var_96) = &input.stream_arn {
object.key("StreamArn").string(var_96.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::SerializationError> {
if let Some(var_97) = &input.table_name {
object.key("TableName").string(var_97.as_str());
}
if let Some(var_98) = &input.stream_arn {
object.key("StreamArn").string(var_98.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::SerializationError> {
if let Some(var_99) = &input.statement {
object.key("Statement").string(var_99.as_str());
}
if let Some(var_100) = &input.parameters {
let mut array_101 = object.key("Parameters").start_array();
for item_102 in var_100 {
{
let mut object_103 = array_101.value().start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_103,
item_102,
)?;
object_103.finish();
}
}
array_101.finish();
}
if let Some(var_104) = &input.consistent_read {
object.key("ConsistentRead").boolean(*var_104);
}
if let Some(var_105) = &input.next_token {
object.key("NextToken").string(var_105.as_str());
}
if let Some(var_106) = &input.return_consumed_capacity {
object
.key("ReturnConsumedCapacity")
.string(var_106.as_str());
}
if let Some(var_107) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_107).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::SerializationError> {
if let Some(var_108) = &input.transact_statements {
let mut array_109 = object.key("TransactStatements").start_array();
for item_110 in var_108 {
{
let mut object_111 = array_109.value().start_object();
crate::json_ser::serialize_structure_crate_model_parameterized_statement(
&mut object_111,
item_110,
)?;
object_111.finish();
}
}
array_109.finish();
}
if let Some(var_112) = &input.client_request_token {
object.key("ClientRequestToken").string(var_112.as_str());
}
if let Some(var_113) = &input.return_consumed_capacity {
object
.key("ReturnConsumedCapacity")
.string(var_113.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::SerializationError> {
if let Some(var_114) = &input.table_arn {
object.key("TableArn").string(var_114.as_str());
}
if let Some(var_115) = &input.export_time {
object
.key("ExportTime")
.date_time(var_115, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_116) = &input.client_token {
object.key("ClientToken").string(var_116.as_str());
}
if let Some(var_117) = &input.s3_bucket {
object.key("S3Bucket").string(var_117.as_str());
}
if let Some(var_118) = &input.s3_bucket_owner {
object.key("S3BucketOwner").string(var_118.as_str());
}
if let Some(var_119) = &input.s3_prefix {
object.key("S3Prefix").string(var_119.as_str());
}
if let Some(var_120) = &input.s3_sse_algorithm {
object.key("S3SseAlgorithm").string(var_120.as_str());
}
if let Some(var_121) = &input.s3_sse_kms_key_id {
object.key("S3SseKmsKeyId").string(var_121.as_str());
}
if let Some(var_122) = &input.export_format {
object.key("ExportFormat").string(var_122.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::SerializationError> {
if let Some(var_123) = &input.table_name {
object.key("TableName").string(var_123.as_str());
}
if let Some(var_124) = &input.key {
let mut object_125 = object.key("Key").start_object();
for (key_126, value_127) in var_124 {
{
let mut object_128 = object_125.key(key_126).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_128,
value_127,
)?;
object_128.finish();
}
}
object_125.finish();
}
if let Some(var_129) = &input.attributes_to_get {
let mut array_130 = object.key("AttributesToGet").start_array();
for item_131 in var_129 {
{
array_130.value().string(item_131.as_str());
}
}
array_130.finish();
}
if let Some(var_132) = &input.consistent_read {
object.key("ConsistentRead").boolean(*var_132);
}
if let Some(var_133) = &input.return_consumed_capacity {
object
.key("ReturnConsumedCapacity")
.string(var_133.as_str());
}
if let Some(var_134) = &input.projection_expression {
object.key("ProjectionExpression").string(var_134.as_str());
}
if let Some(var_135) = &input.expression_attribute_names {
let mut object_136 = object.key("ExpressionAttributeNames").start_object();
for (key_137, value_138) in var_135 {
{
object_136.key(key_137).string(value_138.as_str());
}
}
object_136.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::SerializationError> {
if let Some(var_139) = &input.table_name {
object.key("TableName").string(var_139.as_str());
}
if let Some(var_140) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_140).into()),
);
}
if let Some(var_141) = &input.time_range_lower_bound {
object
.key("TimeRangeLowerBound")
.date_time(var_141, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_142) = &input.time_range_upper_bound {
object
.key("TimeRangeUpperBound")
.date_time(var_142, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_143) = &input.exclusive_start_backup_arn {
object
.key("ExclusiveStartBackupArn")
.string(var_143.as_str());
}
if let Some(var_144) = &input.backup_type {
object.key("BackupType").string(var_144.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::SerializationError> {
if let Some(var_145) = &input.table_name {
object.key("TableName").string(var_145.as_str());
}
if let Some(var_146) = &input.next_token {
object.key("NextToken").string(var_146.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::SerializationError> {
if let Some(var_147) = &input.table_arn {
object.key("TableArn").string(var_147.as_str());
}
if let Some(var_148) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_148).into()),
);
}
if let Some(var_149) = &input.next_token {
object.key("NextToken").string(var_149.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::SerializationError> {
if let Some(var_150) = &input.exclusive_start_global_table_name {
object
.key("ExclusiveStartGlobalTableName")
.string(var_150.as_str());
}
if let Some(var_151) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_151).into()),
);
}
if let Some(var_152) = &input.region_name {
object.key("RegionName").string(var_152.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::SerializationError> {
if let Some(var_153) = &input.exclusive_start_table_name {
object
.key("ExclusiveStartTableName")
.string(var_153.as_str());
}
if let Some(var_154) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_154).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::SerializationError> {
if let Some(var_155) = &input.resource_arn {
object.key("ResourceArn").string(var_155.as_str());
}
if let Some(var_156) = &input.next_token {
object.key("NextToken").string(var_156.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::SerializationError> {
if let Some(var_157) = &input.table_name {
object.key("TableName").string(var_157.as_str());
}
if let Some(var_158) = &input.item {
let mut object_159 = object.key("Item").start_object();
for (key_160, value_161) in var_158 {
{
let mut object_162 = object_159.key(key_160).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_162,
value_161,
)?;
object_162.finish();
}
}
object_159.finish();
}
if let Some(var_163) = &input.expected {
let mut object_164 = object.key("Expected").start_object();
for (key_165, value_166) in var_163 {
{
let mut object_167 = object_164.key(key_165).start_object();
crate::json_ser::serialize_structure_crate_model_expected_attribute_value(
&mut object_167,
value_166,
)?;
object_167.finish();
}
}
object_164.finish();
}
if let Some(var_168) = &input.return_values {
object.key("ReturnValues").string(var_168.as_str());
}
if let Some(var_169) = &input.return_consumed_capacity {
object
.key("ReturnConsumedCapacity")
.string(var_169.as_str());
}
if let Some(var_170) = &input.return_item_collection_metrics {
object
.key("ReturnItemCollectionMetrics")
.string(var_170.as_str());
}
if let Some(var_171) = &input.conditional_operator {
object.key("ConditionalOperator").string(var_171.as_str());
}
if let Some(var_172) = &input.condition_expression {
object.key("ConditionExpression").string(var_172.as_str());
}
if let Some(var_173) = &input.expression_attribute_names {
let mut object_174 = object.key("ExpressionAttributeNames").start_object();
for (key_175, value_176) in var_173 {
{
object_174.key(key_175).string(value_176.as_str());
}
}
object_174.finish();
}
if let Some(var_177) = &input.expression_attribute_values {
let mut object_178 = object.key("ExpressionAttributeValues").start_object();
for (key_179, value_180) in var_177 {
{
let mut object_181 = object_178.key(key_179).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_181,
value_180,
)?;
object_181.finish();
}
}
object_178.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::SerializationError> {
if let Some(var_182) = &input.table_name {
object.key("TableName").string(var_182.as_str());
}
if let Some(var_183) = &input.index_name {
object.key("IndexName").string(var_183.as_str());
}
if let Some(var_184) = &input.select {
object.key("Select").string(var_184.as_str());
}
if let Some(var_185) = &input.attributes_to_get {
let mut array_186 = object.key("AttributesToGet").start_array();
for item_187 in var_185 {
{
array_186.value().string(item_187.as_str());
}
}
array_186.finish();
}
if let Some(var_188) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_188).into()),
);
}
if let Some(var_189) = &input.consistent_read {
object.key("ConsistentRead").boolean(*var_189);
}
if let Some(var_190) = &input.key_conditions {
let mut object_191 = object.key("KeyConditions").start_object();
for (key_192, value_193) in var_190 {
{
let mut object_194 = object_191.key(key_192).start_object();
crate::json_ser::serialize_structure_crate_model_condition(
&mut object_194,
value_193,
)?;
object_194.finish();
}
}
object_191.finish();
}
if let Some(var_195) = &input.query_filter {
let mut object_196 = object.key("QueryFilter").start_object();
for (key_197, value_198) in var_195 {
{
let mut object_199 = object_196.key(key_197).start_object();
crate::json_ser::serialize_structure_crate_model_condition(
&mut object_199,
value_198,
)?;
object_199.finish();
}
}
object_196.finish();
}
if let Some(var_200) = &input.conditional_operator {
object.key("ConditionalOperator").string(var_200.as_str());
}
if let Some(var_201) = &input.scan_index_forward {
object.key("ScanIndexForward").boolean(*var_201);
}
if let Some(var_202) = &input.exclusive_start_key {
let mut object_203 = object.key("ExclusiveStartKey").start_object();
for (key_204, value_205) in var_202 {
{
let mut object_206 = object_203.key(key_204).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_206,
value_205,
)?;
object_206.finish();
}
}
object_203.finish();
}
if let Some(var_207) = &input.return_consumed_capacity {
object
.key("ReturnConsumedCapacity")
.string(var_207.as_str());
}
if let Some(var_208) = &input.projection_expression {
object.key("ProjectionExpression").string(var_208.as_str());
}
if let Some(var_209) = &input.filter_expression {
object.key("FilterExpression").string(var_209.as_str());
}
if let Some(var_210) = &input.key_condition_expression {
object
.key("KeyConditionExpression")
.string(var_210.as_str());
}
if let Some(var_211) = &input.expression_attribute_names {
let mut object_212 = object.key("ExpressionAttributeNames").start_object();
for (key_213, value_214) in var_211 {
{
object_212.key(key_213).string(value_214.as_str());
}
}
object_212.finish();
}
if let Some(var_215) = &input.expression_attribute_values {
let mut object_216 = object.key("ExpressionAttributeValues").start_object();
for (key_217, value_218) in var_215 {
{
let mut object_219 = object_216.key(key_217).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_219,
value_218,
)?;
object_219.finish();
}
}
object_216.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::SerializationError> {
if let Some(var_220) = &input.target_table_name {
object.key("TargetTableName").string(var_220.as_str());
}
if let Some(var_221) = &input.backup_arn {
object.key("BackupArn").string(var_221.as_str());
}
if let Some(var_222) = &input.billing_mode_override {
object.key("BillingModeOverride").string(var_222.as_str());
}
if let Some(var_223) = &input.global_secondary_index_override {
let mut array_224 = object.key("GlobalSecondaryIndexOverride").start_array();
for item_225 in var_223 {
{
let mut object_226 = array_224.value().start_object();
crate::json_ser::serialize_structure_crate_model_global_secondary_index(
&mut object_226,
item_225,
)?;
object_226.finish();
}
}
array_224.finish();
}
if let Some(var_227) = &input.local_secondary_index_override {
let mut array_228 = object.key("LocalSecondaryIndexOverride").start_array();
for item_229 in var_227 {
{
let mut object_230 = array_228.value().start_object();
crate::json_ser::serialize_structure_crate_model_local_secondary_index(
&mut object_230,
item_229,
)?;
object_230.finish();
}
}
array_228.finish();
}
if let Some(var_231) = &input.provisioned_throughput_override {
let mut object_232 = object.key("ProvisionedThroughputOverride").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput(
&mut object_232,
var_231,
)?;
object_232.finish();
}
if let Some(var_233) = &input.sse_specification_override {
let mut object_234 = object.key("SSESpecificationOverride").start_object();
crate::json_ser::serialize_structure_crate_model_sse_specification(
&mut object_234,
var_233,
)?;
object_234.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::SerializationError> {
if let Some(var_235) = &input.source_table_arn {
object.key("SourceTableArn").string(var_235.as_str());
}
if let Some(var_236) = &input.source_table_name {
object.key("SourceTableName").string(var_236.as_str());
}
if let Some(var_237) = &input.target_table_name {
object.key("TargetTableName").string(var_237.as_str());
}
if let Some(var_238) = &input.use_latest_restorable_time {
object.key("UseLatestRestorableTime").boolean(*var_238);
}
if let Some(var_239) = &input.restore_date_time {
object
.key("RestoreDateTime")
.date_time(var_239, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_240) = &input.billing_mode_override {
object.key("BillingModeOverride").string(var_240.as_str());
}
if let Some(var_241) = &input.global_secondary_index_override {
let mut array_242 = object.key("GlobalSecondaryIndexOverride").start_array();
for item_243 in var_241 {
{
let mut object_244 = array_242.value().start_object();
crate::json_ser::serialize_structure_crate_model_global_secondary_index(
&mut object_244,
item_243,
)?;
object_244.finish();
}
}
array_242.finish();
}
if let Some(var_245) = &input.local_secondary_index_override {
let mut array_246 = object.key("LocalSecondaryIndexOverride").start_array();
for item_247 in var_245 {
{
let mut object_248 = array_246.value().start_object();
crate::json_ser::serialize_structure_crate_model_local_secondary_index(
&mut object_248,
item_247,
)?;
object_248.finish();
}
}
array_246.finish();
}
if let Some(var_249) = &input.provisioned_throughput_override {
let mut object_250 = object.key("ProvisionedThroughputOverride").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput(
&mut object_250,
var_249,
)?;
object_250.finish();
}
if let Some(var_251) = &input.sse_specification_override {
let mut object_252 = object.key("SSESpecificationOverride").start_object();
crate::json_ser::serialize_structure_crate_model_sse_specification(
&mut object_252,
var_251,
)?;
object_252.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::SerializationError> {
if let Some(var_253) = &input.table_name {
object.key("TableName").string(var_253.as_str());
}
if let Some(var_254) = &input.index_name {
object.key("IndexName").string(var_254.as_str());
}
if let Some(var_255) = &input.attributes_to_get {
let mut array_256 = object.key("AttributesToGet").start_array();
for item_257 in var_255 {
{
array_256.value().string(item_257.as_str());
}
}
array_256.finish();
}
if let Some(var_258) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_258).into()),
);
}
if let Some(var_259) = &input.select {
object.key("Select").string(var_259.as_str());
}
if let Some(var_260) = &input.scan_filter {
let mut object_261 = object.key("ScanFilter").start_object();
for (key_262, value_263) in var_260 {
{
let mut object_264 = object_261.key(key_262).start_object();
crate::json_ser::serialize_structure_crate_model_condition(
&mut object_264,
value_263,
)?;
object_264.finish();
}
}
object_261.finish();
}
if let Some(var_265) = &input.conditional_operator {
object.key("ConditionalOperator").string(var_265.as_str());
}
if let Some(var_266) = &input.exclusive_start_key {
let mut object_267 = object.key("ExclusiveStartKey").start_object();
for (key_268, value_269) in var_266 {
{
let mut object_270 = object_267.key(key_268).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_270,
value_269,
)?;
object_270.finish();
}
}
object_267.finish();
}
if let Some(var_271) = &input.return_consumed_capacity {
object
.key("ReturnConsumedCapacity")
.string(var_271.as_str());
}
if let Some(var_272) = &input.total_segments {
object.key("TotalSegments").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_272).into()),
);
}
if let Some(var_273) = &input.segment {
object.key("Segment").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_273).into()),
);
}
if let Some(var_274) = &input.projection_expression {
object.key("ProjectionExpression").string(var_274.as_str());
}
if let Some(var_275) = &input.filter_expression {
object.key("FilterExpression").string(var_275.as_str());
}
if let Some(var_276) = &input.expression_attribute_names {
let mut object_277 = object.key("ExpressionAttributeNames").start_object();
for (key_278, value_279) in var_276 {
{
object_277.key(key_278).string(value_279.as_str());
}
}
object_277.finish();
}
if let Some(var_280) = &input.expression_attribute_values {
let mut object_281 = object.key("ExpressionAttributeValues").start_object();
for (key_282, value_283) in var_280 {
{
let mut object_284 = object_281.key(key_282).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_284,
value_283,
)?;
object_284.finish();
}
}
object_281.finish();
}
if let Some(var_285) = &input.consistent_read {
object.key("ConsistentRead").boolean(*var_285);
}
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::SerializationError> {
if let Some(var_286) = &input.resource_arn {
object.key("ResourceArn").string(var_286.as_str());
}
if let Some(var_287) = &input.tags {
let mut array_288 = object.key("Tags").start_array();
for item_289 in var_287 {
{
let mut object_290 = array_288.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_290, item_289)?;
object_290.finish();
}
}
array_288.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::SerializationError> {
if let Some(var_291) = &input.transact_items {
let mut array_292 = object.key("TransactItems").start_array();
for item_293 in var_291 {
{
let mut object_294 = array_292.value().start_object();
crate::json_ser::serialize_structure_crate_model_transact_get_item(
&mut object_294,
item_293,
)?;
object_294.finish();
}
}
array_292.finish();
}
if let Some(var_295) = &input.return_consumed_capacity {
object
.key("ReturnConsumedCapacity")
.string(var_295.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::SerializationError> {
if let Some(var_296) = &input.transact_items {
let mut array_297 = object.key("TransactItems").start_array();
for item_298 in var_296 {
{
let mut object_299 = array_297.value().start_object();
crate::json_ser::serialize_structure_crate_model_transact_write_item(
&mut object_299,
item_298,
)?;
object_299.finish();
}
}
array_297.finish();
}
if let Some(var_300) = &input.return_consumed_capacity {
object
.key("ReturnConsumedCapacity")
.string(var_300.as_str());
}
if let Some(var_301) = &input.return_item_collection_metrics {
object
.key("ReturnItemCollectionMetrics")
.string(var_301.as_str());
}
if let Some(var_302) = &input.client_request_token {
object.key("ClientRequestToken").string(var_302.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::SerializationError> {
if let Some(var_303) = &input.resource_arn {
object.key("ResourceArn").string(var_303.as_str());
}
if let Some(var_304) = &input.tag_keys {
let mut array_305 = object.key("TagKeys").start_array();
for item_306 in var_304 {
{
array_305.value().string(item_306.as_str());
}
}
array_305.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::SerializationError> {
if let Some(var_307) = &input.table_name {
object.key("TableName").string(var_307.as_str());
}
if let Some(var_308) = &input.point_in_time_recovery_specification {
let mut object_309 = object
.key("PointInTimeRecoverySpecification")
.start_object();
crate::json_ser::serialize_structure_crate_model_point_in_time_recovery_specification(
&mut object_309,
var_308,
)?;
object_309.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::SerializationError> {
if let Some(var_310) = &input.table_name {
object.key("TableName").string(var_310.as_str());
}
if let Some(var_311) = &input.index_name {
object.key("IndexName").string(var_311.as_str());
}
if let Some(var_312) = &input.contributor_insights_action {
object
.key("ContributorInsightsAction")
.string(var_312.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::SerializationError> {
if let Some(var_313) = &input.global_table_name {
object.key("GlobalTableName").string(var_313.as_str());
}
if let Some(var_314) = &input.replica_updates {
let mut array_315 = object.key("ReplicaUpdates").start_array();
for item_316 in var_314 {
{
let mut object_317 = array_315.value().start_object();
crate::json_ser::serialize_structure_crate_model_replica_update(
&mut object_317,
item_316,
)?;
object_317.finish();
}
}
array_315.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::SerializationError> {
if let Some(var_318) = &input.global_table_name {
object.key("GlobalTableName").string(var_318.as_str());
}
if let Some(var_319) = &input.global_table_billing_mode {
object
.key("GlobalTableBillingMode")
.string(var_319.as_str());
}
if let Some(var_320) = &input.global_table_provisioned_write_capacity_units {
object
.key("GlobalTableProvisionedWriteCapacityUnits")
.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_320).into()),
);
}
if let Some(var_321) =
&input.global_table_provisioned_write_capacity_auto_scaling_settings_update
{
let mut object_322 = object
.key("GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate")
.start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_settings_update(
&mut object_322,
var_321,
)?;
object_322.finish();
}
if let Some(var_323) = &input.global_table_global_secondary_index_settings_update {
let mut array_324 = object
.key("GlobalTableGlobalSecondaryIndexSettingsUpdate")
.start_array();
for item_325 in var_323 {
{
let mut object_326 = array_324.value().start_object();
crate::json_ser::serialize_structure_crate_model_global_table_global_secondary_index_settings_update(&mut object_326, item_325)?;
object_326.finish();
}
}
array_324.finish();
}
if let Some(var_327) = &input.replica_settings_update {
let mut array_328 = object.key("ReplicaSettingsUpdate").start_array();
for item_329 in var_327 {
{
let mut object_330 = array_328.value().start_object();
crate::json_ser::serialize_structure_crate_model_replica_settings_update(
&mut object_330,
item_329,
)?;
object_330.finish();
}
}
array_328.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::SerializationError> {
if let Some(var_331) = &input.table_name {
object.key("TableName").string(var_331.as_str());
}
if let Some(var_332) = &input.key {
let mut object_333 = object.key("Key").start_object();
for (key_334, value_335) in var_332 {
{
let mut object_336 = object_333.key(key_334).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_336,
value_335,
)?;
object_336.finish();
}
}
object_333.finish();
}
if let Some(var_337) = &input.attribute_updates {
let mut object_338 = object.key("AttributeUpdates").start_object();
for (key_339, value_340) in var_337 {
{
let mut object_341 = object_338.key(key_339).start_object();
crate::json_ser::serialize_structure_crate_model_attribute_value_update(
&mut object_341,
value_340,
)?;
object_341.finish();
}
}
object_338.finish();
}
if let Some(var_342) = &input.expected {
let mut object_343 = object.key("Expected").start_object();
for (key_344, value_345) in var_342 {
{
let mut object_346 = object_343.key(key_344).start_object();
crate::json_ser::serialize_structure_crate_model_expected_attribute_value(
&mut object_346,
value_345,
)?;
object_346.finish();
}
}
object_343.finish();
}
if let Some(var_347) = &input.conditional_operator {
object.key("ConditionalOperator").string(var_347.as_str());
}
if let Some(var_348) = &input.return_values {
object.key("ReturnValues").string(var_348.as_str());
}
if let Some(var_349) = &input.return_consumed_capacity {
object
.key("ReturnConsumedCapacity")
.string(var_349.as_str());
}
if let Some(var_350) = &input.return_item_collection_metrics {
object
.key("ReturnItemCollectionMetrics")
.string(var_350.as_str());
}
if let Some(var_351) = &input.update_expression {
object.key("UpdateExpression").string(var_351.as_str());
}
if let Some(var_352) = &input.condition_expression {
object.key("ConditionExpression").string(var_352.as_str());
}
if let Some(var_353) = &input.expression_attribute_names {
let mut object_354 = object.key("ExpressionAttributeNames").start_object();
for (key_355, value_356) in var_353 {
{
object_354.key(key_355).string(value_356.as_str());
}
}
object_354.finish();
}
if let Some(var_357) = &input.expression_attribute_values {
let mut object_358 = object.key("ExpressionAttributeValues").start_object();
for (key_359, value_360) in var_357 {
{
let mut object_361 = object_358.key(key_359).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_361,
value_360,
)?;
object_361.finish();
}
}
object_358.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::SerializationError> {
if let Some(var_362) = &input.attribute_definitions {
let mut array_363 = object.key("AttributeDefinitions").start_array();
for item_364 in var_362 {
{
let mut object_365 = array_363.value().start_object();
crate::json_ser::serialize_structure_crate_model_attribute_definition(
&mut object_365,
item_364,
)?;
object_365.finish();
}
}
array_363.finish();
}
if let Some(var_366) = &input.table_name {
object.key("TableName").string(var_366.as_str());
}
if let Some(var_367) = &input.billing_mode {
object.key("BillingMode").string(var_367.as_str());
}
if let Some(var_368) = &input.provisioned_throughput {
let mut object_369 = object.key("ProvisionedThroughput").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput(
&mut object_369,
var_368,
)?;
object_369.finish();
}
if let Some(var_370) = &input.global_secondary_index_updates {
let mut array_371 = object.key("GlobalSecondaryIndexUpdates").start_array();
for item_372 in var_370 {
{
let mut object_373 = array_371.value().start_object();
crate::json_ser::serialize_structure_crate_model_global_secondary_index_update(
&mut object_373,
item_372,
)?;
object_373.finish();
}
}
array_371.finish();
}
if let Some(var_374) = &input.stream_specification {
let mut object_375 = object.key("StreamSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_stream_specification(
&mut object_375,
var_374,
)?;
object_375.finish();
}
if let Some(var_376) = &input.sse_specification {
let mut object_377 = object.key("SSESpecification").start_object();
crate::json_ser::serialize_structure_crate_model_sse_specification(
&mut object_377,
var_376,
)?;
object_377.finish();
}
if let Some(var_378) = &input.replica_updates {
let mut array_379 = object.key("ReplicaUpdates").start_array();
for item_380 in var_378 {
{
let mut object_381 = array_379.value().start_object();
crate::json_ser::serialize_structure_crate_model_replication_group_update(
&mut object_381,
item_380,
)?;
object_381.finish();
}
}
array_379.finish();
}
if let Some(var_382) = &input.table_class {
object.key("TableClass").string(var_382.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::SerializationError> {
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 {
{
let mut object_386 = array_384.value().start_object();
crate::json_ser::serialize_structure_crate_model_global_secondary_index_auto_scaling_update(&mut object_386, item_385)?;
object_386.finish();
}
}
array_384.finish();
}
if let Some(var_387) = &input.table_name {
object.key("TableName").string(var_387.as_str());
}
if let Some(var_388) = &input.provisioned_write_capacity_auto_scaling_update {
let mut object_389 = object
.key("ProvisionedWriteCapacityAutoScalingUpdate")
.start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_settings_update(
&mut object_389,
var_388,
)?;
object_389.finish();
}
if let Some(var_390) = &input.replica_updates {
let mut array_391 = object.key("ReplicaUpdates").start_array();
for item_392 in var_390 {
{
let mut object_393 = array_391.value().start_object();
crate::json_ser::serialize_structure_crate_model_replica_auto_scaling_update(
&mut object_393,
item_392,
)?;
object_393.finish();
}
}
array_391.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::SerializationError> {
if let Some(var_394) = &input.table_name {
object.key("TableName").string(var_394.as_str());
}
if let Some(var_395) = &input.time_to_live_specification {
let mut object_396 = object.key("TimeToLiveSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_time_to_live_specification(
&mut object_396,
var_395,
)?;
object_396.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::SerializationError> {
if let Some(var_397) = &input.statement {
object.key("Statement").string(var_397.as_str());
}
if let Some(var_398) = &input.parameters {
let mut array_399 = object.key("Parameters").start_array();
for item_400 in var_398 {
{
let mut object_401 = array_399.value().start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_401,
item_400,
)?;
object_401.finish();
}
}
array_399.finish();
}
if let Some(var_402) = &input.consistent_read {
object.key("ConsistentRead").boolean(*var_402);
}
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::SerializationError> {
if let Some(var_403) = &input.keys {
let mut array_404 = object.key("Keys").start_array();
for item_405 in var_403 {
{
let mut object_406 = array_404.value().start_object();
for (key_407, value_408) in item_405 {
{
let mut object_409 = object_406.key(key_407).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_409,
value_408,
)?;
object_409.finish();
}
}
object_406.finish();
}
}
array_404.finish();
}
if let Some(var_410) = &input.attributes_to_get {
let mut array_411 = object.key("AttributesToGet").start_array();
for item_412 in var_410 {
{
array_411.value().string(item_412.as_str());
}
}
array_411.finish();
}
if let Some(var_413) = &input.consistent_read {
object.key("ConsistentRead").boolean(*var_413);
}
if let Some(var_414) = &input.projection_expression {
object.key("ProjectionExpression").string(var_414.as_str());
}
if let Some(var_415) = &input.expression_attribute_names {
let mut object_416 = object.key("ExpressionAttributeNames").start_object();
for (key_417, value_418) in var_415 {
{
object_416.key(key_417).string(value_418.as_str());
}
}
object_416.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::SerializationError> {
if let Some(var_419) = &input.put_request {
let mut object_420 = object.key("PutRequest").start_object();
crate::json_ser::serialize_structure_crate_model_put_request(&mut object_420, var_419)?;
object_420.finish();
}
if let Some(var_421) = &input.delete_request {
let mut object_422 = object.key("DeleteRequest").start_object();
crate::json_ser::serialize_structure_crate_model_delete_request(&mut object_422, var_421)?;
object_422.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::SerializationError> {
if let Some(var_423) = &input.region_name {
object.key("RegionName").string(var_423.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::SerializationError> {
if let Some(var_424) = &input.attribute_name {
object.key("AttributeName").string(var_424.as_str());
}
if let Some(var_425) = &input.attribute_type {
object.key("AttributeType").string(var_425.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::SerializationError> {
if let Some(var_426) = &input.attribute_name {
object.key("AttributeName").string(var_426.as_str());
}
if let Some(var_427) = &input.key_type {
object.key("KeyType").string(var_427.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::SerializationError> {
if let Some(var_428) = &input.index_name {
object.key("IndexName").string(var_428.as_str());
}
if let Some(var_429) = &input.key_schema {
let mut array_430 = object.key("KeySchema").start_array();
for item_431 in var_429 {
{
let mut object_432 = array_430.value().start_object();
crate::json_ser::serialize_structure_crate_model_key_schema_element(
&mut object_432,
item_431,
)?;
object_432.finish();
}
}
array_430.finish();
}
if let Some(var_433) = &input.projection {
let mut object_434 = object.key("Projection").start_object();
crate::json_ser::serialize_structure_crate_model_projection(&mut object_434, var_433)?;
object_434.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::SerializationError> {
if let Some(var_435) = &input.index_name {
object.key("IndexName").string(var_435.as_str());
}
if let Some(var_436) = &input.key_schema {
let mut array_437 = object.key("KeySchema").start_array();
for item_438 in var_436 {
{
let mut object_439 = array_437.value().start_object();
crate::json_ser::serialize_structure_crate_model_key_schema_element(
&mut object_439,
item_438,
)?;
object_439.finish();
}
}
array_437.finish();
}
if let Some(var_440) = &input.projection {
let mut object_441 = object.key("Projection").start_object();
crate::json_ser::serialize_structure_crate_model_projection(&mut object_441, var_440)?;
object_441.finish();
}
if let Some(var_442) = &input.provisioned_throughput {
let mut object_443 = object.key("ProvisionedThroughput").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput(
&mut object_443,
var_442,
)?;
object_443.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::SerializationError> {
if let Some(var_444) = &input.read_capacity_units {
object.key("ReadCapacityUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_444).into()),
);
}
if let Some(var_445) = &input.write_capacity_units {
object.key("WriteCapacityUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_445).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::SerializationError> {
if let Some(var_446) = &input.stream_enabled {
object.key("StreamEnabled").boolean(*var_446);
}
if let Some(var_447) = &input.stream_view_type {
object.key("StreamViewType").string(var_447.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::SerializationError> {
if let Some(var_448) = &input.enabled {
object.key("Enabled").boolean(*var_448);
}
if let Some(var_449) = &input.sse_type {
object.key("SSEType").string(var_449.as_str());
}
if let Some(var_450) = &input.kms_master_key_id {
object.key("KMSMasterKeyId").string(var_450.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::SerializationError> {
if let Some(var_451) = &input.key {
object.key("Key").string(var_451.as_str());
}
if let Some(var_452) = &input.value {
object.key("Value").string(var_452.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::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_453 = object_63.key("SS").start_array();
for item_454 in inner {
{
array_453.value().string(item_454.as_str());
}
}
array_453.finish();
}
crate::model::AttributeValue::Ns(inner) => {
let mut array_455 = object_63.key("NS").start_array();
for item_456 in inner {
{
array_455.value().string(item_456.as_str());
}
}
array_455.finish();
}
crate::model::AttributeValue::Bs(inner) => {
let mut array_457 = object_63.key("BS").start_array();
for item_458 in inner {
{
array_457
.value()
.string_unchecked(&aws_smithy_types::base64::encode(item_458));
}
}
array_457.finish();
}
crate::model::AttributeValue::M(inner) => {
let mut object_459 = object_63.key("M").start_object();
for (key_460, value_461) in inner {
{
let mut object_462 = object_459.key(key_460).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_462,
value_461,
)?;
object_462.finish();
}
}
object_459.finish();
}
crate::model::AttributeValue::L(inner) => {
let mut array_463 = object_63.key("L").start_array();
for item_464 in inner {
{
let mut object_465 = array_463.value().start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_465,
item_464,
)?;
object_465.finish();
}
}
array_463.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::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::SerializationError> {
if let Some(var_466) = &input.value {
let mut object_467 = object.key("Value").start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(&mut object_467, var_466)?;
object_467.finish();
}
if let Some(var_468) = &input.exists {
object.key("Exists").boolean(*var_468);
}
if let Some(var_469) = &input.comparison_operator {
object.key("ComparisonOperator").string(var_469.as_str());
}
if let Some(var_470) = &input.attribute_value_list {
let mut array_471 = object.key("AttributeValueList").start_array();
for item_472 in var_470 {
{
let mut object_473 = array_471.value().start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_473,
item_472,
)?;
object_473.finish();
}
}
array_471.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::SerializationError> {
if let Some(var_474) = &input.statement {
object.key("Statement").string(var_474.as_str());
}
if let Some(var_475) = &input.parameters {
let mut array_476 = object.key("Parameters").start_array();
for item_477 in var_475 {
{
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();
}
Ok(())
}
pub fn serialize_structure_crate_model_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Condition,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_479) = &input.attribute_value_list {
let mut array_480 = object.key("AttributeValueList").start_array();
for item_481 in var_479 {
{
let mut object_482 = array_480.value().start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_482,
item_481,
)?;
object_482.finish();
}
}
array_480.finish();
}
if let Some(var_483) = &input.comparison_operator {
object.key("ComparisonOperator").string(var_483.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::SerializationError> {
if let Some(var_484) = &input.get {
let mut object_485 = object.key("Get").start_object();
crate::json_ser::serialize_structure_crate_model_get(&mut object_485, var_484)?;
object_485.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::SerializationError> {
if let Some(var_486) = &input.condition_check {
let mut object_487 = object.key("ConditionCheck").start_object();
crate::json_ser::serialize_structure_crate_model_condition_check(&mut object_487, var_486)?;
object_487.finish();
}
if let Some(var_488) = &input.put {
let mut object_489 = object.key("Put").start_object();
crate::json_ser::serialize_structure_crate_model_put(&mut object_489, var_488)?;
object_489.finish();
}
if let Some(var_490) = &input.delete {
let mut object_491 = object.key("Delete").start_object();
crate::json_ser::serialize_structure_crate_model_delete(&mut object_491, var_490)?;
object_491.finish();
}
if let Some(var_492) = &input.update {
let mut object_493 = object.key("Update").start_object();
crate::json_ser::serialize_structure_crate_model_update(&mut object_493, var_492)?;
object_493.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::SerializationError> {
if let Some(var_494) = &input.point_in_time_recovery_enabled {
object.key("PointInTimeRecoveryEnabled").boolean(*var_494);
}
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::SerializationError> {
if let Some(var_495) = &input.create {
let mut object_496 = object.key("Create").start_object();
crate::json_ser::serialize_structure_crate_model_create_replica_action(
&mut object_496,
var_495,
)?;
object_496.finish();
}
if let Some(var_497) = &input.delete {
let mut object_498 = object.key("Delete").start_object();
crate::json_ser::serialize_structure_crate_model_delete_replica_action(
&mut object_498,
var_497,
)?;
object_498.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::SerializationError> {
if let Some(var_499) = &input.minimum_units {
object.key("MinimumUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_499).into()),
);
}
if let Some(var_500) = &input.maximum_units {
object.key("MaximumUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_500).into()),
);
}
if let Some(var_501) = &input.auto_scaling_disabled {
object.key("AutoScalingDisabled").boolean(*var_501);
}
if let Some(var_502) = &input.auto_scaling_role_arn {
object.key("AutoScalingRoleArn").string(var_502.as_str());
}
if let Some(var_503) = &input.scaling_policy_update {
let mut object_504 = object.key("ScalingPolicyUpdate").start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_policy_update(
&mut object_504,
var_503,
)?;
object_504.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::SerializationError> {
if let Some(var_505) = &input.index_name {
object.key("IndexName").string(var_505.as_str());
}
if let Some(var_506) = &input.provisioned_write_capacity_units {
object.key("ProvisionedWriteCapacityUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_506).into()),
);
}
if let Some(var_507) = &input.provisioned_write_capacity_auto_scaling_settings_update {
let mut object_508 = object
.key("ProvisionedWriteCapacityAutoScalingSettingsUpdate")
.start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_settings_update(
&mut object_508,
var_507,
)?;
object_508.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::SerializationError> {
if let Some(var_509) = &input.region_name {
object.key("RegionName").string(var_509.as_str());
}
if let Some(var_510) = &input.replica_provisioned_read_capacity_units {
object.key("ReplicaProvisionedReadCapacityUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_510).into()),
);
}
if let Some(var_511) = &input.replica_provisioned_read_capacity_auto_scaling_settings_update {
let mut object_512 = object
.key("ReplicaProvisionedReadCapacityAutoScalingSettingsUpdate")
.start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_settings_update(
&mut object_512,
var_511,
)?;
object_512.finish();
}
if let Some(var_513) = &input.replica_global_secondary_index_settings_update {
let mut array_514 = object
.key("ReplicaGlobalSecondaryIndexSettingsUpdate")
.start_array();
for item_515 in var_513 {
{
let mut object_516 = array_514.value().start_object();
crate::json_ser::serialize_structure_crate_model_replica_global_secondary_index_settings_update(&mut object_516, item_515)?;
object_516.finish();
}
}
array_514.finish();
}
if let Some(var_517) = &input.replica_table_class {
object.key("ReplicaTableClass").string(var_517.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::SerializationError> {
if let Some(var_518) = &input.value {
let mut object_519 = object.key("Value").start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(&mut object_519, var_518)?;
object_519.finish();
}
if let Some(var_520) = &input.action {
object.key("Action").string(var_520.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::SerializationError> {
if let Some(var_521) = &input.update {
let mut object_522 = object.key("Update").start_object();
crate::json_ser::serialize_structure_crate_model_update_global_secondary_index_action(
&mut object_522,
var_521,
)?;
object_522.finish();
}
if let Some(var_523) = &input.create {
let mut object_524 = object.key("Create").start_object();
crate::json_ser::serialize_structure_crate_model_create_global_secondary_index_action(
&mut object_524,
var_523,
)?;
object_524.finish();
}
if let Some(var_525) = &input.delete {
let mut object_526 = object.key("Delete").start_object();
crate::json_ser::serialize_structure_crate_model_delete_global_secondary_index_action(
&mut object_526,
var_525,
)?;
object_526.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::SerializationError> {
if let Some(var_527) = &input.create {
let mut object_528 = object.key("Create").start_object();
crate::json_ser::serialize_structure_crate_model_create_replication_group_member_action(
&mut object_528,
var_527,
)?;
object_528.finish();
}
if let Some(var_529) = &input.update {
let mut object_530 = object.key("Update").start_object();
crate::json_ser::serialize_structure_crate_model_update_replication_group_member_action(
&mut object_530,
var_529,
)?;
object_530.finish();
}
if let Some(var_531) = &input.delete {
let mut object_532 = object.key("Delete").start_object();
crate::json_ser::serialize_structure_crate_model_delete_replication_group_member_action(
&mut object_532,
var_531,
)?;
object_532.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::SerializationError> {
if let Some(var_533) = &input.index_name {
object.key("IndexName").string(var_533.as_str());
}
if let Some(var_534) = &input.provisioned_write_capacity_auto_scaling_update {
let mut object_535 = object
.key("ProvisionedWriteCapacityAutoScalingUpdate")
.start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_settings_update(
&mut object_535,
var_534,
)?;
object_535.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::SerializationError> {
if let Some(var_536) = &input.region_name {
object.key("RegionName").string(var_536.as_str());
}
if let Some(var_537) = &input.replica_global_secondary_index_updates {
let mut array_538 = object
.key("ReplicaGlobalSecondaryIndexUpdates")
.start_array();
for item_539 in var_537 {
{
let mut object_540 = array_538.value().start_object();
crate::json_ser::serialize_structure_crate_model_replica_global_secondary_index_auto_scaling_update(&mut object_540, item_539)?;
object_540.finish();
}
}
array_538.finish();
}
if let Some(var_541) = &input.replica_provisioned_read_capacity_auto_scaling_update {
let mut object_542 = object
.key("ReplicaProvisionedReadCapacityAutoScalingUpdate")
.start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_settings_update(
&mut object_542,
var_541,
)?;
object_542.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::SerializationError> {
if let Some(var_543) = &input.enabled {
object.key("Enabled").boolean(*var_543);
}
if let Some(var_544) = &input.attribute_name {
object.key("AttributeName").string(var_544.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::SerializationError> {
if let Some(var_545) = &input.item {
let mut object_546 = object.key("Item").start_object();
for (key_547, value_548) in var_545 {
{
let mut object_549 = object_546.key(key_547).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_549,
value_548,
)?;
object_549.finish();
}
}
object_546.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::SerializationError> {
if let Some(var_550) = &input.key {
let mut object_551 = object.key("Key").start_object();
for (key_552, value_553) in var_550 {
{
let mut object_554 = object_551.key(key_552).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_554,
value_553,
)?;
object_554.finish();
}
}
object_551.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::SerializationError> {
if let Some(var_555) = &input.projection_type {
object.key("ProjectionType").string(var_555.as_str());
}
if let Some(var_556) = &input.non_key_attributes {
let mut array_557 = object.key("NonKeyAttributes").start_array();
for item_558 in var_556 {
{
array_557.value().string(item_558.as_str());
}
}
array_557.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::SerializationError> {
if let Some(var_559) = &input.key {
let mut object_560 = object.key("Key").start_object();
for (key_561, value_562) in var_559 {
{
let mut object_563 = object_560.key(key_561).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_563,
value_562,
)?;
object_563.finish();
}
}
object_560.finish();
}
if let Some(var_564) = &input.table_name {
object.key("TableName").string(var_564.as_str());
}
if let Some(var_565) = &input.projection_expression {
object.key("ProjectionExpression").string(var_565.as_str());
}
if let Some(var_566) = &input.expression_attribute_names {
let mut object_567 = object.key("ExpressionAttributeNames").start_object();
for (key_568, value_569) in var_566 {
{
object_567.key(key_568).string(value_569.as_str());
}
}
object_567.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::SerializationError> {
if let Some(var_570) = &input.key {
let mut object_571 = object.key("Key").start_object();
for (key_572, value_573) in var_570 {
{
let mut object_574 = object_571.key(key_572).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_574,
value_573,
)?;
object_574.finish();
}
}
object_571.finish();
}
if let Some(var_575) = &input.table_name {
object.key("TableName").string(var_575.as_str());
}
if let Some(var_576) = &input.condition_expression {
object.key("ConditionExpression").string(var_576.as_str());
}
if let Some(var_577) = &input.expression_attribute_names {
let mut object_578 = object.key("ExpressionAttributeNames").start_object();
for (key_579, value_580) in var_577 {
{
object_578.key(key_579).string(value_580.as_str());
}
}
object_578.finish();
}
if let Some(var_581) = &input.expression_attribute_values {
let mut object_582 = object.key("ExpressionAttributeValues").start_object();
for (key_583, value_584) in var_581 {
{
let mut object_585 = object_582.key(key_583).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_585,
value_584,
)?;
object_585.finish();
}
}
object_582.finish();
}
if let Some(var_586) = &input.return_values_on_condition_check_failure {
object
.key("ReturnValuesOnConditionCheckFailure")
.string(var_586.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::SerializationError> {
if let Some(var_587) = &input.item {
let mut object_588 = object.key("Item").start_object();
for (key_589, value_590) in var_587 {
{
let mut object_591 = object_588.key(key_589).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_591,
value_590,
)?;
object_591.finish();
}
}
object_588.finish();
}
if let Some(var_592) = &input.table_name {
object.key("TableName").string(var_592.as_str());
}
if let Some(var_593) = &input.condition_expression {
object.key("ConditionExpression").string(var_593.as_str());
}
if let Some(var_594) = &input.expression_attribute_names {
let mut object_595 = object.key("ExpressionAttributeNames").start_object();
for (key_596, value_597) in var_594 {
{
object_595.key(key_596).string(value_597.as_str());
}
}
object_595.finish();
}
if let Some(var_598) = &input.expression_attribute_values {
let mut object_599 = object.key("ExpressionAttributeValues").start_object();
for (key_600, value_601) in var_598 {
{
let mut object_602 = object_599.key(key_600).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_602,
value_601,
)?;
object_602.finish();
}
}
object_599.finish();
}
if let Some(var_603) = &input.return_values_on_condition_check_failure {
object
.key("ReturnValuesOnConditionCheckFailure")
.string(var_603.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::SerializationError> {
if let Some(var_604) = &input.key {
let mut object_605 = object.key("Key").start_object();
for (key_606, value_607) in var_604 {
{
let mut object_608 = object_605.key(key_606).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_608,
value_607,
)?;
object_608.finish();
}
}
object_605.finish();
}
if let Some(var_609) = &input.table_name {
object.key("TableName").string(var_609.as_str());
}
if let Some(var_610) = &input.condition_expression {
object.key("ConditionExpression").string(var_610.as_str());
}
if let Some(var_611) = &input.expression_attribute_names {
let mut object_612 = object.key("ExpressionAttributeNames").start_object();
for (key_613, value_614) in var_611 {
{
object_612.key(key_613).string(value_614.as_str());
}
}
object_612.finish();
}
if let Some(var_615) = &input.expression_attribute_values {
let mut object_616 = object.key("ExpressionAttributeValues").start_object();
for (key_617, value_618) in var_615 {
{
let mut object_619 = object_616.key(key_617).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_619,
value_618,
)?;
object_619.finish();
}
}
object_616.finish();
}
if let Some(var_620) = &input.return_values_on_condition_check_failure {
object
.key("ReturnValuesOnConditionCheckFailure")
.string(var_620.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::SerializationError> {
if let Some(var_621) = &input.key {
let mut object_622 = object.key("Key").start_object();
for (key_623, value_624) in var_621 {
{
let mut object_625 = object_622.key(key_623).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.update_expression {
object.key("UpdateExpression").string(var_626.as_str());
}
if let Some(var_627) = &input.table_name {
object.key("TableName").string(var_627.as_str());
}
if let Some(var_628) = &input.condition_expression {
object.key("ConditionExpression").string(var_628.as_str());
}
if let Some(var_629) = &input.expression_attribute_names {
let mut object_630 = object.key("ExpressionAttributeNames").start_object();
for (key_631, value_632) in var_629 {
{
object_630.key(key_631).string(value_632.as_str());
}
}
object_630.finish();
}
if let Some(var_633) = &input.expression_attribute_values {
let mut object_634 = object.key("ExpressionAttributeValues").start_object();
for (key_635, value_636) in var_633 {
{
let mut object_637 = object_634.key(key_635).start_object();
crate::json_ser::serialize_union_crate_model_attribute_value(
&mut object_637,
value_636,
)?;
object_637.finish();
}
}
object_634.finish();
}
if let Some(var_638) = &input.return_values_on_condition_check_failure {
object
.key("ReturnValuesOnConditionCheckFailure")
.string(var_638.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::SerializationError> {
if let Some(var_639) = &input.region_name {
object.key("RegionName").string(var_639.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::SerializationError> {
if let Some(var_640) = &input.region_name {
object.key("RegionName").string(var_640.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::SerializationError> {
if let Some(var_641) = &input.policy_name {
object.key("PolicyName").string(var_641.as_str());
}
if let Some(var_642) = &input.target_tracking_scaling_policy_configuration {
let mut object_643 = object
.key("TargetTrackingScalingPolicyConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_target_tracking_scaling_policy_configuration_update(&mut object_643, var_642)?;
object_643.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::SerializationError> {
if let Some(var_644) = &input.index_name {
object.key("IndexName").string(var_644.as_str());
}
if let Some(var_645) = &input.provisioned_read_capacity_units {
object.key("ProvisionedReadCapacityUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_645).into()),
);
}
if let Some(var_646) = &input.provisioned_read_capacity_auto_scaling_settings_update {
let mut object_647 = object
.key("ProvisionedReadCapacityAutoScalingSettingsUpdate")
.start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_settings_update(
&mut object_647,
var_646,
)?;
object_647.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::SerializationError> {
if let Some(var_648) = &input.index_name {
object.key("IndexName").string(var_648.as_str());
}
if let Some(var_649) = &input.provisioned_throughput {
let mut object_650 = object.key("ProvisionedThroughput").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput(
&mut object_650,
var_649,
)?;
object_650.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::SerializationError> {
if let Some(var_651) = &input.index_name {
object.key("IndexName").string(var_651.as_str());
}
if let Some(var_652) = &input.key_schema {
let mut array_653 = object.key("KeySchema").start_array();
for item_654 in var_652 {
{
let mut object_655 = array_653.value().start_object();
crate::json_ser::serialize_structure_crate_model_key_schema_element(
&mut object_655,
item_654,
)?;
object_655.finish();
}
}
array_653.finish();
}
if let Some(var_656) = &input.projection {
let mut object_657 = object.key("Projection").start_object();
crate::json_ser::serialize_structure_crate_model_projection(&mut object_657, var_656)?;
object_657.finish();
}
if let Some(var_658) = &input.provisioned_throughput {
let mut object_659 = object.key("ProvisionedThroughput").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput(
&mut object_659,
var_658,
)?;
object_659.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::SerializationError> {
if let Some(var_660) = &input.index_name {
object.key("IndexName").string(var_660.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::SerializationError> {
if let Some(var_661) = &input.region_name {
object.key("RegionName").string(var_661.as_str());
}
if let Some(var_662) = &input.kms_master_key_id {
object.key("KMSMasterKeyId").string(var_662.as_str());
}
if let Some(var_663) = &input.provisioned_throughput_override {
let mut object_664 = object.key("ProvisionedThroughputOverride").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput_override(
&mut object_664,
var_663,
)?;
object_664.finish();
}
if let Some(var_665) = &input.global_secondary_indexes {
let mut array_666 = object.key("GlobalSecondaryIndexes").start_array();
for item_667 in var_665 {
{
let mut object_668 = array_666.value().start_object();
crate::json_ser::serialize_structure_crate_model_replica_global_secondary_index(
&mut object_668,
item_667,
)?;
object_668.finish();
}
}
array_666.finish();
}
if let Some(var_669) = &input.table_class_override {
object.key("TableClassOverride").string(var_669.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::SerializationError> {
if let Some(var_670) = &input.region_name {
object.key("RegionName").string(var_670.as_str());
}
if let Some(var_671) = &input.kms_master_key_id {
object.key("KMSMasterKeyId").string(var_671.as_str());
}
if let Some(var_672) = &input.provisioned_throughput_override {
let mut object_673 = object.key("ProvisionedThroughputOverride").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput_override(
&mut object_673,
var_672,
)?;
object_673.finish();
}
if let Some(var_674) = &input.global_secondary_indexes {
let mut array_675 = object.key("GlobalSecondaryIndexes").start_array();
for item_676 in var_674 {
{
let mut object_677 = array_675.value().start_object();
crate::json_ser::serialize_structure_crate_model_replica_global_secondary_index(
&mut object_677,
item_676,
)?;
object_677.finish();
}
}
array_675.finish();
}
if let Some(var_678) = &input.table_class_override {
object.key("TableClassOverride").string(var_678.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::SerializationError> {
if let Some(var_679) = &input.region_name {
object.key("RegionName").string(var_679.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::SerializationError> {
if let Some(var_680) = &input.index_name {
object.key("IndexName").string(var_680.as_str());
}
if let Some(var_681) = &input.provisioned_read_capacity_auto_scaling_update {
let mut object_682 = object
.key("ProvisionedReadCapacityAutoScalingUpdate")
.start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_settings_update(
&mut object_682,
var_681,
)?;
object_682.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::SerializationError> {
if let Some(var_683) = &input.disable_scale_in {
object.key("DisableScaleIn").boolean(*var_683);
}
if let Some(var_684) = &input.scale_in_cooldown {
object.key("ScaleInCooldown").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_684).into()),
);
}
if let Some(var_685) = &input.scale_out_cooldown {
object.key("ScaleOutCooldown").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_685).into()),
);
}
if let Some(var_686) = &input.target_value {
object.key("TargetValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_686).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::SerializationError> {
if let Some(var_687) = &input.read_capacity_units {
object.key("ReadCapacityUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_687).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::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_override {
let mut object_690 = object.key("ProvisionedThroughputOverride").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput_override(
&mut object_690,
var_689,
)?;
object_690.finish();
}
Ok(())
}