pub fn serialize_structure_crate_input_batch_create_table_rows_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchCreateTableRowsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.client_request_token {
object.key("clientRequestToken").string(var_1.as_str());
}
if let Some(var_2) = &input.rows_to_create {
let mut array_3 = object.key("rowsToCreate").start_array();
for item_4 in var_2 {
{
#[allow(unused_mut)]
let mut object_5 = array_3.value().start_object();
crate::json_ser::serialize_structure_crate_model_create_row_data(
&mut object_5,
item_4,
)?;
object_5.finish();
}
}
array_3.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_delete_table_rows_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDeleteTableRowsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_6) = &input.client_request_token {
object.key("clientRequestToken").string(var_6.as_str());
}
if let Some(var_7) = &input.row_ids {
let mut array_8 = object.key("rowIds").start_array();
for item_9 in var_7 {
{
array_8.value().string(item_9.as_str());
}
}
array_8.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_update_table_rows_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchUpdateTableRowsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_10) = &input.client_request_token {
object.key("clientRequestToken").string(var_10.as_str());
}
if let Some(var_11) = &input.rows_to_update {
let mut array_12 = object.key("rowsToUpdate").start_array();
for item_13 in var_11 {
{
#[allow(unused_mut)]
let mut object_14 = array_12.value().start_object();
crate::json_ser::serialize_structure_crate_model_update_row_data(
&mut object_14,
item_13,
)?;
object_14.finish();
}
}
array_12.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_upsert_table_rows_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchUpsertTableRowsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_15) = &input.client_request_token {
object.key("clientRequestToken").string(var_15.as_str());
}
if let Some(var_16) = &input.rows_to_upsert {
let mut array_17 = object.key("rowsToUpsert").start_array();
for item_18 in var_16 {
{
#[allow(unused_mut)]
let mut object_19 = array_17.value().start_object();
crate::json_ser::serialize_structure_crate_model_upsert_row_data(
&mut object_19,
item_18,
)?;
object_19.finish();
}
}
array_17.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_screen_data_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetScreenDataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_20) = &input.app_id {
object.key("appId").string(var_20.as_str());
}
if let Some(var_21) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_21).into()),
);
}
if let Some(var_22) = &input.next_token {
object.key("nextToken").string(var_22.as_str());
}
if let Some(var_23) = &input.screen_id {
object.key("screenId").string(var_23.as_str());
}
if let Some(var_24) = &input.variables {
#[allow(unused_mut)]
let mut object_25 = object.key("variables").start_object();
for (key_26, value_27) in var_24 {
{
#[allow(unused_mut)]
let mut object_28 = object_25.key(key_26.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_variable_value(
&mut object_28,
value_27,
)?;
object_28.finish();
}
}
object_25.finish();
}
if let Some(var_29) = &input.workbook_id {
object.key("workbookId").string(var_29.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_invoke_screen_automation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::InvokeScreenAutomationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_30) = &input.client_request_token {
object.key("clientRequestToken").string(var_30.as_str());
}
if let Some(var_31) = &input.row_id {
object.key("rowId").string(var_31.as_str());
}
if let Some(var_32) = &input.variables {
#[allow(unused_mut)]
let mut object_33 = object.key("variables").start_object();
for (key_34, value_35) in var_32 {
{
#[allow(unused_mut)]
let mut object_36 = object_33.key(key_34.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_variable_value(
&mut object_36,
value_35,
)?;
object_36.finish();
}
}
object_33.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_table_rows_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTableRowsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_37) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_37).into()),
);
}
if let Some(var_38) = &input.next_token {
object.key("nextToken").string(var_38.as_str());
}
if let Some(var_39) = &input.row_ids {
let mut array_40 = object.key("rowIds").start_array();
for item_41 in var_39 {
{
array_40.value().string(item_41.as_str());
}
}
array_40.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_query_table_rows_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::QueryTableRowsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_42) = &input.filter_formula {
#[allow(unused_mut)]
let mut object_43 = object.key("filterFormula").start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_43, var_42)?;
object_43.finish();
}
if let Some(var_44) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_44).into()),
);
}
if let Some(var_45) = &input.next_token {
object.key("nextToken").string(var_45.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_table_data_import_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartTableDataImportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_46) = &input.client_request_token {
object.key("clientRequestToken").string(var_46.as_str());
}
if let Some(var_47) = &input.data_format {
object.key("dataFormat").string(var_47.as_str());
}
if let Some(var_48) = &input.data_source {
#[allow(unused_mut)]
let mut object_49 = object.key("dataSource").start_object();
crate::json_ser::serialize_structure_crate_model_import_data_source(
&mut object_49,
var_48,
)?;
object_49.finish();
}
if let Some(var_50) = &input.import_options {
#[allow(unused_mut)]
let mut object_51 = object.key("importOptions").start_object();
crate::json_ser::serialize_structure_crate_model_import_options(&mut object_51, var_50)?;
object_51.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_52) = &input.tags {
#[allow(unused_mut)]
let mut object_53 = object.key("tags").start_object();
for (key_54, value_55) in var_52 {
{
object_53.key(key_54.as_str()).string(value_55.as_str());
}
}
object_53.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_create_row_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateRowData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_56) = &input.batch_item_id {
object.key("batchItemId").string(var_56.as_str());
}
if let Some(var_57) = &input.cells_to_create {
#[allow(unused_mut)]
let mut object_58 = object.key("cellsToCreate").start_object();
for (key_59, value_60) in var_57 {
{
#[allow(unused_mut)]
let mut object_61 = object_58.key(key_59.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_cell_input(
&mut object_61,
value_60,
)?;
object_61.finish();
}
}
object_58.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_row_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateRowData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_62) = &input.row_id {
object.key("rowId").string(var_62.as_str());
}
if let Some(var_63) = &input.cells_to_update {
#[allow(unused_mut)]
let mut object_64 = object.key("cellsToUpdate").start_object();
for (key_65, value_66) in var_63 {
{
#[allow(unused_mut)]
let mut object_67 = object_64.key(key_65.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_cell_input(
&mut object_67,
value_66,
)?;
object_67.finish();
}
}
object_64.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_upsert_row_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpsertRowData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_68) = &input.batch_item_id {
object.key("batchItemId").string(var_68.as_str());
}
if let Some(var_69) = &input.filter {
#[allow(unused_mut)]
let mut object_70 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_70, var_69)?;
object_70.finish();
}
if let Some(var_71) = &input.cells_to_update {
#[allow(unused_mut)]
let mut object_72 = object.key("cellsToUpdate").start_object();
for (key_73, value_74) in var_71 {
{
#[allow(unused_mut)]
let mut object_75 = object_72.key(key_73.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_cell_input(
&mut object_75,
value_74,
)?;
object_75.finish();
}
}
object_72.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_variable_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VariableValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_76) = &input.raw_value {
object.key("rawValue").string(var_76.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Filter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_77) = &input.formula {
object.key("formula").string(var_77.as_str());
}
if let Some(var_78) = &input.context_row_id {
object.key("contextRowId").string(var_78.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_import_data_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImportDataSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_79) = &input.data_source_config {
#[allow(unused_mut)]
let mut object_80 = object.key("dataSourceConfig").start_object();
crate::json_ser::serialize_structure_crate_model_import_data_source_config(
&mut object_80,
var_79,
)?;
object_80.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_import_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImportOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.destination_options {
#[allow(unused_mut)]
let mut object_82 = object.key("destinationOptions").start_object();
crate::json_ser::serialize_structure_crate_model_destination_options(
&mut object_82,
var_81,
)?;
object_82.finish();
}
if let Some(var_83) = &input.delimited_text_options {
#[allow(unused_mut)]
let mut object_84 = object.key("delimitedTextOptions").start_object();
crate::json_ser::serialize_structure_crate_model_delimited_text_import_options(
&mut object_84,
var_83,
)?;
object_84.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_cell_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CellInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.fact {
object.key("fact").string(var_85.as_str());
}
if let Some(var_86) = &input.facts {
let mut array_87 = object.key("facts").start_array();
for item_88 in var_86 {
{
array_87.value().string(item_88.as_str());
}
}
array_87.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_import_data_source_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImportDataSourceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.data_source_url {
object.key("dataSourceUrl").string(var_89.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_destination_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DestinationOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_90) = &input.column_map {
#[allow(unused_mut)]
let mut object_91 = object.key("columnMap").start_object();
for (key_92, value_93) in var_90 {
{
#[allow(unused_mut)]
let mut object_94 = object_91.key(key_92.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_source_data_column_properties(
&mut object_94,
value_93,
)?;
object_94.finish();
}
}
object_91.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_delimited_text_import_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DelimitedTextImportOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_95) = &input.delimiter {
object.key("delimiter").string(var_95.as_str());
}
if input.has_header_row {
object.key("hasHeaderRow").boolean(input.has_header_row);
}
if input.ignore_empty_rows {
object
.key("ignoreEmptyRows")
.boolean(input.ignore_empty_rows);
}
if let Some(var_96) = &input.data_character_encoding {
object.key("dataCharacterEncoding").string(var_96.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_source_data_column_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SourceDataColumnProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.column_index != 0 {
object.key("columnIndex").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.column_index).into()),
);
}
Ok(())
}