Client Test

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

pub fn ser_create_backup_input_input(

    object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,

    input: &crate::operation::create_backup::CreateBackupInput,

) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {

    if let Some(var_1) = &input.table_name {

        object.key("TableName").string(var_1.as_str());

    }

    if let Some(var_2) = &input.backup_name {

        object.key("BackupName").string(var_2.as_str());

    }

    Ok(())

}

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

pub fn ser_create_global_secondary_index_action(

    object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,

    input: &crate::types::CreateGlobalSecondaryIndexAction,

) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {

    {

        object.key("IndexName").string(input.index_name.as_str());

    }

    {

        let mut array_1 = object.key("KeySchema").start_array();

        for item_2 in &input.key_schema {

            {

                #[allow(unused_mut)]

                let mut object_3 = array_1.value().start_object();

                crate::protocol_serde::shape_key_schema_element::ser_key_schema_element(&mut object_3, item_2)?;

                object_3.finish();

            }

        }

        array_1.finish();

    }

    {

        #[allow(unused_mut)]

        let mut object_4 = object.key("Projection").start_object();

        crate::protocol_serde::shape_projection::ser_projection(&mut object_4, &input.projection)?;

        object_4.finish();

    }

    if let Some(var_5) = &input.provisioned_throughput {

        #[allow(unused_mut)]

        let mut object_6 = object.key("ProvisionedThroughput").start_object();

        crate::protocol_serde::shape_provisioned_throughput::ser_provisioned_throughput(&mut object_6, var_5)?;

        object_6.finish();

    }

    Ok(())

}

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

#[allow(clippy::unnecessary_wraps)]

pub fn de_create_global_table_http_error(

    _response_status: u16,

    _response_headers: &::aws_smithy_runtime_api::http::Headers,

    _response_body: &[u8],

) -> std::result::Result<crate::operation::create_global_table::CreateGlobalTableOutput, crate::operation::create_global_table::CreateGlobalTableError>

{

    #[allow(unused_mut)]

    let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)

        .map_err(crate::operation::create_global_table::CreateGlobalTableError::unhandled)?;

    let generic = generic_builder.build();

    let error_code = match generic.code() {

        Some(code) => code,

        None => return Err(crate::operation::create_global_table::CreateGlobalTableError::unhandled(generic)),

    };

    let _error_message = generic.message().map(|msg| msg.to_owned());

    Err(match error_code {

        "GlobalTableAlreadyExistsException" => crate::operation::create_global_table::CreateGlobalTableError::GlobalTableAlreadyExistsError({

            #[allow(unused_mut)]

            let mut tmp = {

                #[allow(unused_mut)]

                let mut output = crate::types::error::builders::GlobalTableAlreadyExistsErrorBuilder::default();

                output = crate::protocol_serde::shape_global_table_already_exists_exception::de_global_table_already_exists_exception_json_err(

                    _response_body,

                    output,

                )

                .map_err(crate::operation::create_global_table::CreateGlobalTableError::unhandled)?;

                let output = output.meta(generic);

                output.build()

            };

            if tmp.message.is_none() {

                tmp.message = _error_message;

            }

            tmp

        }),

        "InternalServerError" => crate::operation::create_global_table::CreateGlobalTableError::InternalServerError({

            #[allow(unused_mut)]

            let mut tmp = {

                #[allow(unused_mut)]

                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();

                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)

                    .map_err(crate::operation::create_global_table::CreateGlobalTableError::unhandled)?;

                let output = output.meta(generic);

                output.build()

            };

            if tmp.message.is_none() {

                tmp.message = _error_message;

            }

            tmp

        }),

        "InvalidEndpointException" => crate::operation::create_global_table::CreateGlobalTableError::InvalidEndpointError({

            #[allow(unused_mut)]

            let mut tmp = {

                #[allow(unused_mut)]

                let mut output = crate::types::error::builders::InvalidEndpointErrorBuilder::default();

                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)

                    .map_err(crate::operation::create_global_table::CreateGlobalTableError::unhandled)?;

                let output = output.meta(generic);

                output.build()

            };

            if tmp.message.is_none() {

                tmp.message = _error_message;

            }

            tmp

        }),

        "LimitExceededException" => crate::operation::create_global_table::CreateGlobalTableError::LimitExceededError({

            #[allow(unused_mut)]

            let mut tmp = {

                #[allow(unused_mut)]

                let mut output = crate::types::error::builders::LimitExceededErrorBuilder::default();

                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)

                    .map_err(crate::operation::create_global_table::CreateGlobalTableError::unhandled)?;

                let output = output.meta(generic);

                output.build()

            };

            if tmp.message.is_none() {

                tmp.message = _error_message;

            }

            tmp

        }),

        "TableNotFoundException" => crate::operation::create_global_table::CreateGlobalTableError::TableNotFoundError({

            #[allow(unused_mut)]

            let mut tmp = {

                #[allow(unused_mut)]

                let mut output = crate::types::error::builders::TableNotFoundErrorBuilder::default();

                output = crate::protocol_serde::shape_table_not_found_exception::de_table_not_found_exception_json_err(_response_body, output)

                    .map_err(crate::operation::create_global_table::CreateGlobalTableError::unhandled)?;

                let output = output.meta(generic);

                output.build()

            };

            if tmp.message.is_none() {

                tmp.message = _error_message;

            }

            tmp

        }),

        _ => crate::operation::create_global_table::CreateGlobalTableError::generic(generic),

    })

}

#[allow(clippy::unnecessary_wraps)]

pub fn de_create_global_table_http_response(

    _response_status: u16,

    _response_headers: &::aws_smithy_runtime_api::http::Headers,

    _response_body: &[u8],

) -> std::result::Result<crate::operation::create_global_table::CreateGlobalTableOutput, crate::operation::create_global_table::CreateGlobalTableError>

{

    Ok({

        #[allow(unused_mut)]

        let mut output = crate::operation::create_global_table::builders::CreateGlobalTableOutputBuilder::default();

        output = crate::protocol_serde::shape_create_global_table::de_create_global_table(_response_body, output)

            .map_err(crate::operation::create_global_table::CreateGlobalTableError::unhandled)?;

        output.build()

    })

}

pub fn ser_create_global_table_input(

    input: &crate::operation::create_global_table::CreateGlobalTableInput,

) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {

    let mut out = String::new();

    let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);

    crate::protocol_serde::shape_create_global_table_input::ser_create_global_table_input_input(&mut object, input)?;

    object.finish();

    Ok(::aws_smithy_types::body::SdkBody::from(out))

}

pub(crate) fn de_create_global_table(

    _value: &[u8],

    mut builder: crate::operation::create_global_table::builders::CreateGlobalTableOutputBuilder,

) -> ::std::result::Result<

    crate::operation::create_global_table::builders::CreateGlobalTableOutputBuilder,

    ::aws_smithy_json::deserialize::error::DeserializeError,

> {

    let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(_value)).peekable();

    let tokens = &mut tokens_owned;

    ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;

    loop {

        match tokens.next().transpose()? {

            Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,

            Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {

                "GlobalTableDescription" => {

                    builder = builder.set_global_table_description(

                        crate::protocol_serde::shape_global_table_description::de_global_table_description(tokens, _value)?,

                    );

                }

                _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,

            },

            other => {

                return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(

                    "expected object key or end object, found: {other:?}"

                )))

            }

        }

    }

    if tokens.next().is_some() {

        return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(

            "found more JSON tokens after completing parsing",

        ));

    }

    Ok(builder)

}

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

pub fn ser_create_global_table_input_input(

    object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,

    input: &crate::operation::create_global_table::CreateGlobalTableInput,

) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {

    if let Some(var_1) = &input.global_table_name {

        object.key("GlobalTableName").string(var_1.as_str());

    }

    if let Some(var_2) = &input.replication_group {

        let mut array_3 = object.key("ReplicationGroup").start_array();

        for item_4 in var_2 {

            {

                #[allow(unused_mut)]

                let mut object_5 = array_3.value().start_object();

                crate::protocol_serde::shape_replica::ser_replica(&mut object_5, item_4)?;

                object_5.finish();

            }

        }

        array_3.finish();

    }

    Ok(())

}

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

pub fn ser_create_replica_action(

    object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,

    input: &crate::types::CreateReplicaAction,

) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {

    {

        object.key("RegionName").string(input.region_name.as_str());

    }

    Ok(())

}

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

pub fn ser_create_replication_group_member_action(

    object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,

    input: &crate::types::CreateReplicationGroupMemberAction,

) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {

    {

        object.key("RegionName").string(input.region_name.as_str());

    }

    if let Some(var_1) = &input.kms_master_key_id {

        object.key("KMSMasterKeyId").string(var_1.as_str());

    }

    if let Some(var_2) = &input.provisioned_throughput_override {

        #[allow(unused_mut)]

        let mut object_3 = object.key("ProvisionedThroughputOverride").start_object();

        crate::protocol_serde::shape_provisioned_throughput_override::ser_provisioned_throughput_override(&mut object_3, var_2)?;

        object_3.finish();

    }

    if let Some(var_4) = &input.global_secondary_indexes {

        let mut array_5 = object.key("GlobalSecondaryIndexes").start_array();

        for item_6 in var_4 {

            {

                #[allow(unused_mut)]

                let mut object_7 = array_5.value().start_object();

                crate::protocol_serde::shape_replica_global_secondary_index::ser_replica_global_secondary_index(&mut object_7, item_6)?;

                object_7.finish();

            }

        }

        array_5.finish();

    }

    Ok(())

}

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

#[allow(clippy::unnecessary_wraps)]

pub fn de_create_table_http_error(

    _response_status: u16,

    _response_headers: &::aws_smithy_runtime_api::http::Headers,

    _response_body: &[u8],

) -> std::result::Result<crate::operation::create_table::CreateTableOutput, crate::operation::create_table::CreateTableError> {

    #[allow(unused_mut)]

    let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)

        .map_err(crate::operation::create_table::CreateTableError::unhandled)?;

    let generic = generic_builder.build();

    let error_code = match generic.code() {

        Some(code) => code,

        None => return Err(crate::operation::create_table::CreateTableError::unhandled(generic)),

    };

    let _error_message = generic.message().map(|msg| msg.to_owned());

    Err(match error_code {

        "InternalServerError" => crate::operation::create_table::CreateTableError::InternalServerError({

            #[allow(unused_mut)]

            let mut tmp = {

                #[allow(unused_mut)]

                let mut output = crate::types::error::builders::InternalServerErrorBuilder::default();

                output = crate::protocol_serde::shape_internal_server_error::de_internal_server_error_json_err(_response_body, output)

                    .map_err(crate::operation::create_table::CreateTableError::unhandled)?;

                let output = output.meta(generic);

                output.build()

            };

            if tmp.message.is_none() {

                tmp.message = _error_message;

            }

            tmp

        }),

        "InvalidEndpointException" => crate::operation::create_table::CreateTableError::InvalidEndpointError({

            #[allow(unused_mut)]

            let mut tmp = {

                #[allow(unused_mut)]

                let mut output = crate::types::error::builders::InvalidEndpointErrorBuilder::default();

                output = crate::protocol_serde::shape_invalid_endpoint_exception::de_invalid_endpoint_exception_json_err(_response_body, output)

                    .map_err(crate::operation::create_table::CreateTableError::unhandled)?;

                let output = output.meta(generic);

                output.build()

            };

            if tmp.message.is_none() {

                tmp.message = _error_message;

            }

            tmp

        }),

        "LimitExceededException" => crate::operation::create_table::CreateTableError::LimitExceededError({

            #[allow(unused_mut)]

            let mut tmp = {

                #[allow(unused_mut)]

                let mut output = crate::types::error::builders::LimitExceededErrorBuilder::default();

                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)

                    .map_err(crate::operation::create_table::CreateTableError::unhandled)?;

                let output = output.meta(generic);

                output.build()

            };

            if tmp.message.is_none() {

                tmp.message = _error_message;

            }

            tmp

        }),

        "ResourceInUseException" => crate::operation::create_table::CreateTableError::ResourceInUseError({

            #[allow(unused_mut)]

            let mut tmp = {

                #[allow(unused_mut)]

                let mut output = crate::types::error::builders::ResourceInUseErrorBuilder::default();

                output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_json_err(_response_body, output)

                    .map_err(crate::operation::create_table::CreateTableError::unhandled)?;

                let output = output.meta(generic);

                output.build()

            };

            if tmp.message.is_none() {

                tmp.message = _error_message;

            }

            tmp

        }),

        _ => crate::operation::create_table::CreateTableError::generic(generic),

    })

}

#[allow(clippy::unnecessary_wraps)]

pub fn de_create_table_http_response(

    _response_status: u16,

    _response_headers: &::aws_smithy_runtime_api::http::Headers,

    _response_body: &[u8],

) -> std::result::Result<crate::operation::create_table::CreateTableOutput, crate::operation::create_table::CreateTableError> {

    Ok({

        #[allow(unused_mut)]

        let mut output = crate::operation::create_table::builders::CreateTableOutputBuilder::default();

        output = crate::protocol_serde::shape_create_table::de_create_table(_response_body, output)

            .map_err(crate::operation::create_table::CreateTableError::unhandled)?;

        output.build()

    })

}

pub fn ser_create_table_input(

    input: &crate::operation::create_table::CreateTableInput,

) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {

    let mut out = String::new();

    let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);

    crate::protocol_serde::shape_create_table_input::ser_create_table_input_input(&mut object, input)?;

    object.finish();

    Ok(::aws_smithy_types::body::SdkBody::from(out))

}

pub(crate) fn de_create_table(

    _value: &[u8],

    mut builder: crate::operation::create_table::builders::CreateTableOutputBuilder,

) -> ::std::result::Result<crate::operation::create_table::builders::CreateTableOutputBuilder, ::aws_smithy_json::deserialize::error::DeserializeError>

{

    let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(_value)).peekable();

    let tokens = &mut tokens_owned;

    ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;

    loop {

        match tokens.next().transpose()? {

            Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,

            Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {

                "TableDescription" => {

                    builder = builder.set_table_description(crate::protocol_serde::shape_table_description::de_table_description(tokens, _value)?);

                }

                _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,

            },

            other => {

                return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(

                    "expected object key or end object, found: {other:?}"

                )))

            }

        }

    }

    if tokens.next().is_some() {

        return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(

            "found more JSON tokens after completing parsing",

        ));

    }

    Ok(builder)

}

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

pub fn ser_create_table_input_input(

    object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,

    input: &crate::operation::create_table::CreateTableInput,

) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {

    if let Some(var_1) = &input.attribute_definitions {

        let mut array_2 = object.key("AttributeDefinitions").start_array();

        for item_3 in var_1 {

            {

                #[allow(unused_mut)]

                let mut object_4 = array_2.value().start_object();

                crate::protocol_serde::shape_attribute_definition::ser_attribute_definition(&mut object_4, item_3)?;

                object_4.finish();

            }

        }

        array_2.finish();

    }

    if let Some(var_5) = &input.table_name {

        object.key("TableName").string(var_5.as_str());

    }

    if let Some(var_6) = &input.key_schema {

        let mut array_7 = object.key("KeySchema").start_array();

        for item_8 in var_6 {

            {

                #[allow(unused_mut)]

                let mut object_9 = array_7.value().start_object();

                crate::protocol_serde::shape_key_schema_element::ser_key_schema_element(&mut object_9, item_8)?;

                object_9.finish();

            }

        }

        array_7.finish();

    }

    if let Some(var_10) = &input.local_secondary_indexes {

        let mut array_11 = object.key("LocalSecondaryIndexes").start_array();

        for item_12 in var_10 {

            {

                #[allow(unused_mut)]

                let mut object_13 = array_11.value().start_object();

                crate::protocol_serde::shape_local_secondary_index::ser_local_secondary_index(&mut object_13, item_12)?;

                object_13.finish();

            }

        }

        array_11.finish();

    }

    if let Some(var_14) = &input.global_secondary_indexes {

        let mut array_15 = object.key("GlobalSecondaryIndexes").start_array();

        for item_16 in var_14 {

            {

                #[allow(unused_mut)]

                let mut object_17 = array_15.value().start_object();

                crate::protocol_serde::shape_global_secondary_index::ser_global_secondary_index(&mut object_17, item_16)?;

                object_17.finish();

            }

        }

        array_15.finish();

    }

    if let Some(var_18) = &input.billing_mode {

        object.key("BillingMode").string(var_18.as_str());

    }

    if let Some(var_19) = &input.provisioned_throughput {

        #[allow(unused_mut)]

        let mut object_20 = object.key("ProvisionedThroughput").start_object();

        crate::protocol_serde::shape_provisioned_throughput::ser_provisioned_throughput(&mut object_20, var_19)?;

        object_20.finish();

    }

    if let Some(var_21) = &input.stream_specification {

        #[allow(unused_mut)]

        let mut object_22 = object.key("StreamSpecification").start_object();

        crate::protocol_serde::shape_stream_specification::ser_stream_specification(&mut object_22, var_21)?;

        object_22.finish();

    }

    if let Some(var_23) = &input.sse_specification {

        #[allow(unused_mut)]

        let mut object_24 = object.key("SSESpecification").start_object();

        crate::protocol_serde::shape_sse_specification::ser_sse_specification(&mut object_24, var_23)?;

        object_24.finish();

    }

    if let Some(var_25) = &input.tags {

        let mut array_26 = object.key("Tags").start_array();

        for item_27 in var_25 {

            {

                #[allow(unused_mut)]

                let mut object_28 = array_26.value().start_object();

                crate::protocol_serde::shape_tag::ser_tag(&mut object_28, item_27)?;

                object_28.finish();

            }

        }

        array_26.finish();

    }

    Ok(())

}

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

pub fn ser_delete(

    object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,

    input: &crate::types::Delete,

) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {

    {

        #[allow(unused_mut)]

        let mut object_1 = object.key("Key").start_object();

        for (key_2, value_3) in &input.key {

            {

                #[allow(unused_mut)]

                let mut object_4 = object_1.key(key_2.as_str()).start_object();

                crate::protocol_serde::shape_attribute_value::ser_attribute_value(&mut object_4, value_3)?;

                object_4.finish();

            }

        }

        object_1.finish();

    }

    {

        object.key("TableName").string(input.table_name.as_str());

    }

    if let Some(var_5) = &input.condition_expression {

        object.key("ConditionExpression").string(var_5.as_str());

    }

    if let Some(var_6) = &input.expression_attribute_names {

        #[allow(unused_mut)]

        let mut object_7 = object.key("ExpressionAttributeNames").start_object();

        for (key_8, value_9) in var_6 {

            {

                object_7.key(key_8.as_str()).string(value_9.as_str());