pub fn serialize_structure_crate_input_analyze_document_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AnalyzeDocumentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.document {
#[allow(unused_mut)]
let mut object_2 = object.key("Document").start_object();
crate::json_ser::serialize_structure_crate_model_document(&mut object_2, var_1)?;
object_2.finish();
}
if let Some(var_3) = &input.feature_types {
let mut array_4 = object.key("FeatureTypes").start_array();
for item_5 in var_3 {
{
array_4.value().string(item_5.as_str());
}
}
array_4.finish();
}
if let Some(var_6) = &input.human_loop_config {
#[allow(unused_mut)]
let mut object_7 = object.key("HumanLoopConfig").start_object();
crate::json_ser::serialize_structure_crate_model_human_loop_config(&mut object_7, var_6)?;
object_7.finish();
}
if let Some(var_8) = &input.queries_config {
#[allow(unused_mut)]
let mut object_9 = object.key("QueriesConfig").start_object();
crate::json_ser::serialize_structure_crate_model_queries_config(&mut object_9, var_8)?;
object_9.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_analyze_expense_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AnalyzeExpenseInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_10) = &input.document {
#[allow(unused_mut)]
let mut object_11 = object.key("Document").start_object();
crate::json_ser::serialize_structure_crate_model_document(&mut object_11, var_10)?;
object_11.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_analyze_id_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AnalyzeIdInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_12) = &input.document_pages {
let mut array_13 = object.key("DocumentPages").start_array();
for item_14 in var_12 {
{
#[allow(unused_mut)]
let mut object_15 = array_13.value().start_object();
crate::json_ser::serialize_structure_crate_model_document(&mut object_15, item_14)?;
object_15.finish();
}
}
array_13.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_detect_document_text_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DetectDocumentTextInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_16) = &input.document {
#[allow(unused_mut)]
let mut object_17 = object.key("Document").start_object();
crate::json_ser::serialize_structure_crate_model_document(&mut object_17, var_16)?;
object_17.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_document_analysis_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetDocumentAnalysisInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_18) = &input.job_id {
object.key("JobId").string(var_18.as_str());
}
if let Some(var_19) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_19).into()),
);
}
if let Some(var_20) = &input.next_token {
object.key("NextToken").string(var_20.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_document_text_detection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetDocumentTextDetectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_21) = &input.job_id {
object.key("JobId").string(var_21.as_str());
}
if let Some(var_22) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_22).into()),
);
}
if let Some(var_23) = &input.next_token {
object.key("NextToken").string(var_23.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_expense_analysis_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetExpenseAnalysisInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_24) = &input.job_id {
object.key("JobId").string(var_24.as_str());
}
if let Some(var_25) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_25).into()),
);
}
if let Some(var_26) = &input.next_token {
object.key("NextToken").string(var_26.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_lending_analysis_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetLendingAnalysisInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_27) = &input.job_id {
object.key("JobId").string(var_27.as_str());
}
if let Some(var_28) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_28).into()),
);
}
if let Some(var_29) = &input.next_token {
object.key("NextToken").string(var_29.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_lending_analysis_summary_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetLendingAnalysisSummaryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_30) = &input.job_id {
object.key("JobId").string(var_30.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_document_analysis_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartDocumentAnalysisInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.document_location {
#[allow(unused_mut)]
let mut object_32 = object.key("DocumentLocation").start_object();
crate::json_ser::serialize_structure_crate_model_document_location(&mut object_32, var_31)?;
object_32.finish();
}
if let Some(var_33) = &input.feature_types {
let mut array_34 = object.key("FeatureTypes").start_array();
for item_35 in var_33 {
{
array_34.value().string(item_35.as_str());
}
}
array_34.finish();
}
if let Some(var_36) = &input.client_request_token {
object.key("ClientRequestToken").string(var_36.as_str());
}
if let Some(var_37) = &input.job_tag {
object.key("JobTag").string(var_37.as_str());
}
if let Some(var_38) = &input.notification_channel {
#[allow(unused_mut)]
let mut object_39 = object.key("NotificationChannel").start_object();
crate::json_ser::serialize_structure_crate_model_notification_channel(
&mut object_39,
var_38,
)?;
object_39.finish();
}
if let Some(var_40) = &input.output_config {
#[allow(unused_mut)]
let mut object_41 = object.key("OutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_output_config(&mut object_41, var_40)?;
object_41.finish();
}
if let Some(var_42) = &input.kms_key_id {
object.key("KMSKeyId").string(var_42.as_str());
}
if let Some(var_43) = &input.queries_config {
#[allow(unused_mut)]
let mut object_44 = object.key("QueriesConfig").start_object();
crate::json_ser::serialize_structure_crate_model_queries_config(&mut object_44, var_43)?;
object_44.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_document_text_detection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartDocumentTextDetectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_45) = &input.document_location {
#[allow(unused_mut)]
let mut object_46 = object.key("DocumentLocation").start_object();
crate::json_ser::serialize_structure_crate_model_document_location(&mut object_46, var_45)?;
object_46.finish();
}
if let Some(var_47) = &input.client_request_token {
object.key("ClientRequestToken").string(var_47.as_str());
}
if let Some(var_48) = &input.job_tag {
object.key("JobTag").string(var_48.as_str());
}
if let Some(var_49) = &input.notification_channel {
#[allow(unused_mut)]
let mut object_50 = object.key("NotificationChannel").start_object();
crate::json_ser::serialize_structure_crate_model_notification_channel(
&mut object_50,
var_49,
)?;
object_50.finish();
}
if let Some(var_51) = &input.output_config {
#[allow(unused_mut)]
let mut object_52 = object.key("OutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_output_config(&mut object_52, var_51)?;
object_52.finish();
}
if let Some(var_53) = &input.kms_key_id {
object.key("KMSKeyId").string(var_53.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_expense_analysis_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartExpenseAnalysisInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_54) = &input.document_location {
#[allow(unused_mut)]
let mut object_55 = object.key("DocumentLocation").start_object();
crate::json_ser::serialize_structure_crate_model_document_location(&mut object_55, var_54)?;
object_55.finish();
}
if let Some(var_56) = &input.client_request_token {
object.key("ClientRequestToken").string(var_56.as_str());
}
if let Some(var_57) = &input.job_tag {
object.key("JobTag").string(var_57.as_str());
}
if let Some(var_58) = &input.notification_channel {
#[allow(unused_mut)]
let mut object_59 = object.key("NotificationChannel").start_object();
crate::json_ser::serialize_structure_crate_model_notification_channel(
&mut object_59,
var_58,
)?;
object_59.finish();
}
if let Some(var_60) = &input.output_config {
#[allow(unused_mut)]
let mut object_61 = object.key("OutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_output_config(&mut object_61, var_60)?;
object_61.finish();
}
if let Some(var_62) = &input.kms_key_id {
object.key("KMSKeyId").string(var_62.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_lending_analysis_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartLendingAnalysisInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_63) = &input.document_location {
#[allow(unused_mut)]
let mut object_64 = object.key("DocumentLocation").start_object();
crate::json_ser::serialize_structure_crate_model_document_location(&mut object_64, var_63)?;
object_64.finish();
}
if let Some(var_65) = &input.client_request_token {
object.key("ClientRequestToken").string(var_65.as_str());
}
if let Some(var_66) = &input.job_tag {
object.key("JobTag").string(var_66.as_str());
}
if let Some(var_67) = &input.notification_channel {
#[allow(unused_mut)]
let mut object_68 = object.key("NotificationChannel").start_object();
crate::json_ser::serialize_structure_crate_model_notification_channel(
&mut object_68,
var_67,
)?;
object_68.finish();
}
if let Some(var_69) = &input.output_config {
#[allow(unused_mut)]
let mut object_70 = object.key("OutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_output_config(&mut object_70, var_69)?;
object_70.finish();
}
if let Some(var_71) = &input.kms_key_id {
object.key("KMSKeyId").string(var_71.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_document(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Document,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_72) = &input.bytes {
object
.key("Bytes")
.string_unchecked(&aws_smithy_types::base64::encode(var_72));
}
if let Some(var_73) = &input.s3_object {
#[allow(unused_mut)]
let mut object_74 = object.key("S3Object").start_object();
crate::json_ser::serialize_structure_crate_model_s3_object(&mut object_74, var_73)?;
object_74.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_human_loop_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HumanLoopConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_75) = &input.human_loop_name {
object.key("HumanLoopName").string(var_75.as_str());
}
if let Some(var_76) = &input.flow_definition_arn {
object.key("FlowDefinitionArn").string(var_76.as_str());
}
if let Some(var_77) = &input.data_attributes {
#[allow(unused_mut)]
let mut object_78 = object.key("DataAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_human_loop_data_attributes(
&mut object_78,
var_77,
)?;
object_78.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_queries_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::QueriesConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_79) = &input.queries {
let mut array_80 = object.key("Queries").start_array();
for item_81 in var_79 {
{
#[allow(unused_mut)]
let mut object_82 = array_80.value().start_object();
crate::json_ser::serialize_structure_crate_model_query(&mut object_82, item_81)?;
object_82.finish();
}
}
array_80.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_document_location(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DocumentLocation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_83) = &input.s3_object {
#[allow(unused_mut)]
let mut object_84 = object.key("S3Object").start_object();
crate::json_ser::serialize_structure_crate_model_s3_object(&mut object_84, var_83)?;
object_84.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_notification_channel(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NotificationChannel,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.sns_topic_arn {
object.key("SNSTopicArn").string(var_85.as_str());
}
if let Some(var_86) = &input.role_arn {
object.key("RoleArn").string(var_86.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_output_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OutputConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_87) = &input.s3_bucket {
object.key("S3Bucket").string(var_87.as_str());
}
if let Some(var_88) = &input.s3_prefix {
object.key("S3Prefix").string(var_88.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_object(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3Object,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.bucket {
object.key("Bucket").string(var_89.as_str());
}
if let Some(var_90) = &input.name {
object.key("Name").string(var_90.as_str());
}
if let Some(var_91) = &input.version {
object.key("Version").string(var_91.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_human_loop_data_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HumanLoopDataAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_92) = &input.content_classifiers {
let mut array_93 = object.key("ContentClassifiers").start_array();
for item_94 in var_92 {
{
array_93.value().string(item_94.as_str());
}
}
array_93.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_query(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Query,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_95) = &input.text {
object.key("Text").string(var_95.as_str());
}
if let Some(var_96) = &input.alias {
object.key("Alias").string(var_96.as_str());
}
if let Some(var_97) = &input.pages {
let mut array_98 = object.key("Pages").start_array();
for item_99 in var_97 {
{
array_98.value().string(item_99.as_str());
}
}
array_98.finish();
}
Ok(())
}