pub fn serialize_structure_crate_input_batch_detect_dominant_language_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDetectDominantLanguageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.text_list {
let mut array_2 = object.key("TextList").start_array();
for item_3 in var_1 {
{
array_2.value().string(item_3.as_str());
}
}
array_2.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_detect_entities_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDetectEntitiesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_4) = &input.text_list {
let mut array_5 = object.key("TextList").start_array();
for item_6 in var_4 {
{
array_5.value().string(item_6.as_str());
}
}
array_5.finish();
}
if let Some(var_7) = &input.language_code {
object.key("LanguageCode").string(var_7.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_detect_key_phrases_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDetectKeyPhrasesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_8) = &input.text_list {
let mut array_9 = object.key("TextList").start_array();
for item_10 in var_8 {
{
array_9.value().string(item_10.as_str());
}
}
array_9.finish();
}
if let Some(var_11) = &input.language_code {
object.key("LanguageCode").string(var_11.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_detect_sentiment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDetectSentimentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_12) = &input.text_list {
let mut array_13 = object.key("TextList").start_array();
for item_14 in var_12 {
{
array_13.value().string(item_14.as_str());
}
}
array_13.finish();
}
if let Some(var_15) = &input.language_code {
object.key("LanguageCode").string(var_15.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_detect_syntax_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDetectSyntaxInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_16) = &input.text_list {
let mut array_17 = object.key("TextList").start_array();
for item_18 in var_16 {
{
array_17.value().string(item_18.as_str());
}
}
array_17.finish();
}
if let Some(var_19) = &input.language_code {
object.key("LanguageCode").string(var_19.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_detect_targeted_sentiment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDetectTargetedSentimentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_20) = &input.text_list {
let mut array_21 = object.key("TextList").start_array();
for item_22 in var_20 {
{
array_21.value().string(item_22.as_str());
}
}
array_21.finish();
}
if let Some(var_23) = &input.language_code {
object.key("LanguageCode").string(var_23.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_classify_document_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ClassifyDocumentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_24) = &input.text {
object.key("Text").string(var_24.as_str());
}
if let Some(var_25) = &input.endpoint_arn {
object.key("EndpointArn").string(var_25.as_str());
}
if let Some(var_26) = &input.bytes {
object
.key("Bytes")
.string_unchecked(&aws_smithy_types::base64::encode(var_26));
}
if let Some(var_27) = &input.document_reader_config {
#[allow(unused_mut)]
let mut object_28 = object.key("DocumentReaderConfig").start_object();
crate::json_ser::serialize_structure_crate_model_document_reader_config(
&mut object_28,
var_27,
)?;
object_28.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_contains_pii_entities_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ContainsPiiEntitiesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_29) = &input.text {
object.key("Text").string(var_29.as_str());
}
if let Some(var_30) = &input.language_code {
object.key("LanguageCode").string(var_30.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_document_classifier_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDocumentClassifierInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.document_classifier_name {
object.key("DocumentClassifierName").string(var_31.as_str());
}
if let Some(var_32) = &input.version_name {
object.key("VersionName").string(var_32.as_str());
}
if let Some(var_33) = &input.data_access_role_arn {
object.key("DataAccessRoleArn").string(var_33.as_str());
}
if let Some(var_34) = &input.tags {
let mut array_35 = object.key("Tags").start_array();
for item_36 in var_34 {
{
#[allow(unused_mut)]
let mut object_37 = array_35.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_37, item_36)?;
object_37.finish();
}
}
array_35.finish();
}
if let Some(var_38) = &input.input_data_config {
#[allow(unused_mut)]
let mut object_39 = object.key("InputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_document_classifier_input_data_config(
&mut object_39,
var_38,
)?;
object_39.finish();
}
if let Some(var_40) = &input.output_data_config {
#[allow(unused_mut)]
let mut object_41 = object.key("OutputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_document_classifier_output_data_config(
&mut object_41,
var_40,
)?;
object_41.finish();
}
if let Some(var_42) = &input.client_request_token {
object.key("ClientRequestToken").string(var_42.as_str());
}
if let Some(var_43) = &input.language_code {
object.key("LanguageCode").string(var_43.as_str());
}
if let Some(var_44) = &input.volume_kms_key_id {
object.key("VolumeKmsKeyId").string(var_44.as_str());
}
if let Some(var_45) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_46 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_46, var_45)?;
object_46.finish();
}
if let Some(var_47) = &input.mode {
object.key("Mode").string(var_47.as_str());
}
if let Some(var_48) = &input.model_kms_key_id {
object.key("ModelKmsKeyId").string(var_48.as_str());
}
if let Some(var_49) = &input.model_policy {
object.key("ModelPolicy").string(var_49.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateEndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.endpoint_name {
object.key("EndpointName").string(var_50.as_str());
}
if let Some(var_51) = &input.model_arn {
object.key("ModelArn").string(var_51.as_str());
}
if let Some(var_52) = &input.desired_inference_units {
object.key("DesiredInferenceUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_52).into()),
);
}
if let Some(var_53) = &input.client_request_token {
object.key("ClientRequestToken").string(var_53.as_str());
}
if let Some(var_54) = &input.tags {
let mut array_55 = object.key("Tags").start_array();
for item_56 in var_54 {
{
#[allow(unused_mut)]
let mut object_57 = array_55.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_57, item_56)?;
object_57.finish();
}
}
array_55.finish();
}
if let Some(var_58) = &input.data_access_role_arn {
object.key("DataAccessRoleArn").string(var_58.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_entity_recognizer_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateEntityRecognizerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_59) = &input.recognizer_name {
object.key("RecognizerName").string(var_59.as_str());
}
if let Some(var_60) = &input.version_name {
object.key("VersionName").string(var_60.as_str());
}
if let Some(var_61) = &input.data_access_role_arn {
object.key("DataAccessRoleArn").string(var_61.as_str());
}
if let Some(var_62) = &input.tags {
let mut array_63 = object.key("Tags").start_array();
for item_64 in var_62 {
{
#[allow(unused_mut)]
let mut object_65 = array_63.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_65, item_64)?;
object_65.finish();
}
}
array_63.finish();
}
if let Some(var_66) = &input.input_data_config {
#[allow(unused_mut)]
let mut object_67 = object.key("InputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_entity_recognizer_input_data_config(
&mut object_67,
var_66,
)?;
object_67.finish();
}
if let Some(var_68) = &input.client_request_token {
object.key("ClientRequestToken").string(var_68.as_str());
}
if let Some(var_69) = &input.language_code {
object.key("LanguageCode").string(var_69.as_str());
}
if let Some(var_70) = &input.volume_kms_key_id {
object.key("VolumeKmsKeyId").string(var_70.as_str());
}
if let Some(var_71) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_72 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_72, var_71)?;
object_72.finish();
}
if let Some(var_73) = &input.model_kms_key_id {
object.key("ModelKmsKeyId").string(var_73.as_str());
}
if let Some(var_74) = &input.model_policy {
object.key("ModelPolicy").string(var_74.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_document_classifier_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteDocumentClassifierInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_75) = &input.document_classifier_arn {
object.key("DocumentClassifierArn").string(var_75.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteEndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_76) = &input.endpoint_arn {
object.key("EndpointArn").string(var_76.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_entity_recognizer_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteEntityRecognizerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_77) = &input.entity_recognizer_arn {
object.key("EntityRecognizerArn").string(var_77.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_resource_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteResourcePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_78) = &input.resource_arn {
object.key("ResourceArn").string(var_78.as_str());
}
if let Some(var_79) = &input.policy_revision_id {
object.key("PolicyRevisionId").string(var_79.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_document_classification_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDocumentClassificationJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_80) = &input.job_id {
object.key("JobId").string(var_80.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_document_classifier_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDocumentClassifierInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.document_classifier_arn {
object.key("DocumentClassifierArn").string(var_81.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_dominant_language_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDominantLanguageDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_82) = &input.job_id {
object.key("JobId").string(var_82.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_83) = &input.endpoint_arn {
object.key("EndpointArn").string(var_83.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_entities_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEntitiesDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_84) = &input.job_id {
object.key("JobId").string(var_84.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_entity_recognizer_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEntityRecognizerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.entity_recognizer_arn {
object.key("EntityRecognizerArn").string(var_85.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_events_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEventsDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_86) = &input.job_id {
object.key("JobId").string(var_86.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_key_phrases_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeKeyPhrasesDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_87) = &input.job_id {
object.key("JobId").string(var_87.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_pii_entities_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribePiiEntitiesDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_88) = &input.job_id {
object.key("JobId").string(var_88.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_resource_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeResourcePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.resource_arn {
object.key("ResourceArn").string(var_89.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_sentiment_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeSentimentDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_90) = &input.job_id {
object.key("JobId").string(var_90.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_targeted_sentiment_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTargetedSentimentDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_91) = &input.job_id {
object.key("JobId").string(var_91.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_topics_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTopicsDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_92) = &input.job_id {
object.key("JobId").string(var_92.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_detect_dominant_language_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DetectDominantLanguageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.text {
object.key("Text").string(var_93.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_detect_entities_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DetectEntitiesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_94) = &input.text {
object.key("Text").string(var_94.as_str());
}
if let Some(var_95) = &input.language_code {
object.key("LanguageCode").string(var_95.as_str());
}
if let Some(var_96) = &input.endpoint_arn {
object.key("EndpointArn").string(var_96.as_str());
}
if let Some(var_97) = &input.bytes {
object
.key("Bytes")
.string_unchecked(&aws_smithy_types::base64::encode(var_97));
}
if let Some(var_98) = &input.document_reader_config {
#[allow(unused_mut)]
let mut object_99 = object.key("DocumentReaderConfig").start_object();
crate::json_ser::serialize_structure_crate_model_document_reader_config(
&mut object_99,
var_98,
)?;
object_99.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_detect_key_phrases_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DetectKeyPhrasesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_100) = &input.text {
object.key("Text").string(var_100.as_str());
}
if let Some(var_101) = &input.language_code {
object.key("LanguageCode").string(var_101.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_detect_pii_entities_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DetectPiiEntitiesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_102) = &input.text {
object.key("Text").string(var_102.as_str());
}
if let Some(var_103) = &input.language_code {
object.key("LanguageCode").string(var_103.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_detect_sentiment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DetectSentimentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_104) = &input.text {
object.key("Text").string(var_104.as_str());
}
if let Some(var_105) = &input.language_code {
object.key("LanguageCode").string(var_105.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_detect_syntax_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DetectSyntaxInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_106) = &input.text {
object.key("Text").string(var_106.as_str());
}
if let Some(var_107) = &input.language_code {
object.key("LanguageCode").string(var_107.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_detect_targeted_sentiment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DetectTargetedSentimentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_108) = &input.text {
object.key("Text").string(var_108.as_str());
}
if let Some(var_109) = &input.language_code {
object.key("LanguageCode").string(var_109.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_import_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ImportModelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_110) = &input.source_model_arn {
object.key("SourceModelArn").string(var_110.as_str());
}
if let Some(var_111) = &input.model_name {
object.key("ModelName").string(var_111.as_str());
}
if let Some(var_112) = &input.version_name {
object.key("VersionName").string(var_112.as_str());
}
if let Some(var_113) = &input.model_kms_key_id {
object.key("ModelKmsKeyId").string(var_113.as_str());
}
if let Some(var_114) = &input.data_access_role_arn {
object.key("DataAccessRoleArn").string(var_114.as_str());
}
if let Some(var_115) = &input.tags {
let mut array_116 = object.key("Tags").start_array();
for item_117 in var_115 {
{
#[allow(unused_mut)]
let mut object_118 = array_116.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_118, item_117)?;
object_118.finish();
}
}
array_116.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_document_classification_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDocumentClassificationJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_119) = &input.filter {
#[allow(unused_mut)]
let mut object_120 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_document_classification_job_filter(
&mut object_120,
var_119,
)?;
object_120.finish();
}
if let Some(var_121) = &input.next_token {
object.key("NextToken").string(var_121.as_str());
}
if let Some(var_122) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_122).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_document_classifiers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDocumentClassifiersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_123) = &input.filter {
#[allow(unused_mut)]
let mut object_124 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_document_classifier_filter(
&mut object_124,
var_123,
)?;
object_124.finish();
}
if let Some(var_125) = &input.next_token {
object.key("NextToken").string(var_125.as_str());
}
if let Some(var_126) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_126).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_document_classifier_summaries_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDocumentClassifierSummariesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_127) = &input.next_token {
object.key("NextToken").string(var_127.as_str());
}
if let Some(var_128) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_128).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_dominant_language_detection_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDominantLanguageDetectionJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_129) = &input.filter {
#[allow(unused_mut)]
let mut object_130 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_dominant_language_detection_job_filter(
&mut object_130,
var_129,
)?;
object_130.finish();
}
if let Some(var_131) = &input.next_token {
object.key("NextToken").string(var_131.as_str());
}
if let Some(var_132) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_132).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_endpoints_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListEndpointsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_133) = &input.filter {
#[allow(unused_mut)]
let mut object_134 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_filter(&mut object_134, var_133)?;
object_134.finish();
}
if let Some(var_135) = &input.next_token {
object.key("NextToken").string(var_135.as_str());
}
if let Some(var_136) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_136).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_entities_detection_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListEntitiesDetectionJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_137) = &input.filter {
#[allow(unused_mut)]
let mut object_138 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_entities_detection_job_filter(
&mut object_138,
var_137,
)?;
object_138.finish();
}
if let Some(var_139) = &input.next_token {
object.key("NextToken").string(var_139.as_str());
}
if let Some(var_140) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_140).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_entity_recognizers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListEntityRecognizersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_141) = &input.filter {
#[allow(unused_mut)]
let mut object_142 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_entity_recognizer_filter(
&mut object_142,
var_141,
)?;
object_142.finish();
}
if let Some(var_143) = &input.next_token {
object.key("NextToken").string(var_143.as_str());
}
if let Some(var_144) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_144).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_entity_recognizer_summaries_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListEntityRecognizerSummariesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_145) = &input.next_token {
object.key("NextToken").string(var_145.as_str());
}
if let Some(var_146) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_146).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_events_detection_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListEventsDetectionJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_147) = &input.filter {
#[allow(unused_mut)]
let mut object_148 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_events_detection_job_filter(
&mut object_148,
var_147,
)?;
object_148.finish();
}
if let Some(var_149) = &input.next_token {
object.key("NextToken").string(var_149.as_str());
}
if let Some(var_150) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_150).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_key_phrases_detection_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListKeyPhrasesDetectionJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_151) = &input.filter {
#[allow(unused_mut)]
let mut object_152 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_key_phrases_detection_job_filter(
&mut object_152,
var_151,
)?;
object_152.finish();
}
if let Some(var_153) = &input.next_token {
object.key("NextToken").string(var_153.as_str());
}
if let Some(var_154) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_154).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_pii_entities_detection_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPiiEntitiesDetectionJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_155) = &input.filter {
#[allow(unused_mut)]
let mut object_156 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_pii_entities_detection_job_filter(
&mut object_156,
var_155,
)?;
object_156.finish();
}
if let Some(var_157) = &input.next_token {
object.key("NextToken").string(var_157.as_str());
}
if let Some(var_158) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_158).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_sentiment_detection_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSentimentDetectionJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_159) = &input.filter {
#[allow(unused_mut)]
let mut object_160 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_sentiment_detection_job_filter(
&mut object_160,
var_159,
)?;
object_160.finish();
}
if let Some(var_161) = &input.next_token {
object.key("NextToken").string(var_161.as_str());
}
if let Some(var_162) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_162).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tags_for_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTagsForResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_163) = &input.resource_arn {
object.key("ResourceArn").string(var_163.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_targeted_sentiment_detection_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTargetedSentimentDetectionJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_164) = &input.filter {
#[allow(unused_mut)]
let mut object_165 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_targeted_sentiment_detection_job_filter(
&mut object_165,
var_164,
)?;
object_165.finish();
}
if let Some(var_166) = &input.next_token {
object.key("NextToken").string(var_166.as_str());
}
if let Some(var_167) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_167).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_topics_detection_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTopicsDetectionJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_168) = &input.filter {
#[allow(unused_mut)]
let mut object_169 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_topics_detection_job_filter(
&mut object_169,
var_168,
)?;
object_169.finish();
}
if let Some(var_170) = &input.next_token {
object.key("NextToken").string(var_170.as_str());
}
if let Some(var_171) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_171).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_resource_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutResourcePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_172) = &input.resource_arn {
object.key("ResourceArn").string(var_172.as_str());
}
if let Some(var_173) = &input.resource_policy {
object.key("ResourcePolicy").string(var_173.as_str());
}
if let Some(var_174) = &input.policy_revision_id {
object.key("PolicyRevisionId").string(var_174.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_document_classification_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartDocumentClassificationJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_175) = &input.job_name {
object.key("JobName").string(var_175.as_str());
}
if let Some(var_176) = &input.document_classifier_arn {
object.key("DocumentClassifierArn").string(var_176.as_str());
}
if let Some(var_177) = &input.input_data_config {
#[allow(unused_mut)]
let mut object_178 = object.key("InputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_input_data_config(
&mut object_178,
var_177,
)?;
object_178.finish();
}
if let Some(var_179) = &input.output_data_config {
#[allow(unused_mut)]
let mut object_180 = object.key("OutputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_output_data_config(
&mut object_180,
var_179,
)?;
object_180.finish();
}
if let Some(var_181) = &input.data_access_role_arn {
object.key("DataAccessRoleArn").string(var_181.as_str());
}
if let Some(var_182) = &input.client_request_token {
object.key("ClientRequestToken").string(var_182.as_str());
}
if let Some(var_183) = &input.volume_kms_key_id {
object.key("VolumeKmsKeyId").string(var_183.as_str());
}
if let Some(var_184) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_185 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_185, var_184)?;
object_185.finish();
}
if let Some(var_186) = &input.tags {
let mut array_187 = object.key("Tags").start_array();
for item_188 in var_186 {
{
#[allow(unused_mut)]
let mut object_189 = array_187.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_189, item_188)?;
object_189.finish();
}
}
array_187.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_dominant_language_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartDominantLanguageDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_190) = &input.input_data_config {
#[allow(unused_mut)]
let mut object_191 = object.key("InputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_input_data_config(
&mut object_191,
var_190,
)?;
object_191.finish();
}
if let Some(var_192) = &input.output_data_config {
#[allow(unused_mut)]
let mut object_193 = object.key("OutputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_output_data_config(
&mut object_193,
var_192,
)?;
object_193.finish();
}
if let Some(var_194) = &input.data_access_role_arn {
object.key("DataAccessRoleArn").string(var_194.as_str());
}
if let Some(var_195) = &input.job_name {
object.key("JobName").string(var_195.as_str());
}
if let Some(var_196) = &input.client_request_token {
object.key("ClientRequestToken").string(var_196.as_str());
}
if let Some(var_197) = &input.volume_kms_key_id {
object.key("VolumeKmsKeyId").string(var_197.as_str());
}
if let Some(var_198) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_199 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_199, var_198)?;
object_199.finish();
}
if let Some(var_200) = &input.tags {
let mut array_201 = object.key("Tags").start_array();
for item_202 in var_200 {
{
#[allow(unused_mut)]
let mut object_203 = array_201.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_203, item_202)?;
object_203.finish();
}
}
array_201.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_entities_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartEntitiesDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_204) = &input.input_data_config {
#[allow(unused_mut)]
let mut object_205 = object.key("InputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_input_data_config(
&mut object_205,
var_204,
)?;
object_205.finish();
}
if let Some(var_206) = &input.output_data_config {
#[allow(unused_mut)]
let mut object_207 = object.key("OutputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_output_data_config(
&mut object_207,
var_206,
)?;
object_207.finish();
}
if let Some(var_208) = &input.data_access_role_arn {
object.key("DataAccessRoleArn").string(var_208.as_str());
}
if let Some(var_209) = &input.job_name {
object.key("JobName").string(var_209.as_str());
}
if let Some(var_210) = &input.entity_recognizer_arn {
object.key("EntityRecognizerArn").string(var_210.as_str());
}
if let Some(var_211) = &input.language_code {
object.key("LanguageCode").string(var_211.as_str());
}
if let Some(var_212) = &input.client_request_token {
object.key("ClientRequestToken").string(var_212.as_str());
}
if let Some(var_213) = &input.volume_kms_key_id {
object.key("VolumeKmsKeyId").string(var_213.as_str());
}
if let Some(var_214) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_215 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_215, var_214)?;
object_215.finish();
}
if let Some(var_216) = &input.tags {
let mut array_217 = object.key("Tags").start_array();
for item_218 in var_216 {
{
#[allow(unused_mut)]
let mut object_219 = array_217.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_219, item_218)?;
object_219.finish();
}
}
array_217.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_events_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartEventsDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_220) = &input.input_data_config {
#[allow(unused_mut)]
let mut object_221 = object.key("InputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_input_data_config(
&mut object_221,
var_220,
)?;
object_221.finish();
}
if let Some(var_222) = &input.output_data_config {
#[allow(unused_mut)]
let mut object_223 = object.key("OutputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_output_data_config(
&mut object_223,
var_222,
)?;
object_223.finish();
}
if let Some(var_224) = &input.data_access_role_arn {
object.key("DataAccessRoleArn").string(var_224.as_str());
}
if let Some(var_225) = &input.job_name {
object.key("JobName").string(var_225.as_str());
}
if let Some(var_226) = &input.language_code {
object.key("LanguageCode").string(var_226.as_str());
}
if let Some(var_227) = &input.client_request_token {
object.key("ClientRequestToken").string(var_227.as_str());
}
if let Some(var_228) = &input.target_event_types {
let mut array_229 = object.key("TargetEventTypes").start_array();
for item_230 in var_228 {
{
array_229.value().string(item_230.as_str());
}
}
array_229.finish();
}
if let Some(var_231) = &input.tags {
let mut array_232 = object.key("Tags").start_array();
for item_233 in var_231 {
{
#[allow(unused_mut)]
let mut object_234 = array_232.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_234, item_233)?;
object_234.finish();
}
}
array_232.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_key_phrases_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartKeyPhrasesDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_235) = &input.input_data_config {
#[allow(unused_mut)]
let mut object_236 = object.key("InputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_input_data_config(
&mut object_236,
var_235,
)?;
object_236.finish();
}
if let Some(var_237) = &input.output_data_config {
#[allow(unused_mut)]
let mut object_238 = object.key("OutputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_output_data_config(
&mut object_238,
var_237,
)?;
object_238.finish();
}
if let Some(var_239) = &input.data_access_role_arn {
object.key("DataAccessRoleArn").string(var_239.as_str());
}
if let Some(var_240) = &input.job_name {
object.key("JobName").string(var_240.as_str());
}
if let Some(var_241) = &input.language_code {
object.key("LanguageCode").string(var_241.as_str());
}
if let Some(var_242) = &input.client_request_token {
object.key("ClientRequestToken").string(var_242.as_str());
}
if let Some(var_243) = &input.volume_kms_key_id {
object.key("VolumeKmsKeyId").string(var_243.as_str());
}
if let Some(var_244) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_245 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_245, var_244)?;
object_245.finish();
}
if let Some(var_246) = &input.tags {
let mut array_247 = object.key("Tags").start_array();
for item_248 in var_246 {
{
#[allow(unused_mut)]
let mut object_249 = array_247.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_249, item_248)?;
object_249.finish();
}
}
array_247.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_pii_entities_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartPiiEntitiesDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_250) = &input.input_data_config {
#[allow(unused_mut)]
let mut object_251 = object.key("InputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_input_data_config(
&mut object_251,
var_250,
)?;
object_251.finish();
}
if let Some(var_252) = &input.output_data_config {
#[allow(unused_mut)]
let mut object_253 = object.key("OutputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_output_data_config(
&mut object_253,
var_252,
)?;
object_253.finish();
}
if let Some(var_254) = &input.mode {
object.key("Mode").string(var_254.as_str());
}
if let Some(var_255) = &input.redaction_config {
#[allow(unused_mut)]
let mut object_256 = object.key("RedactionConfig").start_object();
crate::json_ser::serialize_structure_crate_model_redaction_config(
&mut object_256,
var_255,
)?;
object_256.finish();
}
if let Some(var_257) = &input.data_access_role_arn {
object.key("DataAccessRoleArn").string(var_257.as_str());
}
if let Some(var_258) = &input.job_name {
object.key("JobName").string(var_258.as_str());
}
if let Some(var_259) = &input.language_code {
object.key("LanguageCode").string(var_259.as_str());
}
if let Some(var_260) = &input.client_request_token {
object.key("ClientRequestToken").string(var_260.as_str());
}
if let Some(var_261) = &input.tags {
let mut array_262 = object.key("Tags").start_array();
for item_263 in var_261 {
{
#[allow(unused_mut)]
let mut object_264 = array_262.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_264, item_263)?;
object_264.finish();
}
}
array_262.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_sentiment_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartSentimentDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_265) = &input.input_data_config {
#[allow(unused_mut)]
let mut object_266 = object.key("InputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_input_data_config(
&mut object_266,
var_265,
)?;
object_266.finish();
}
if let Some(var_267) = &input.output_data_config {
#[allow(unused_mut)]
let mut object_268 = object.key("OutputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_output_data_config(
&mut object_268,
var_267,
)?;
object_268.finish();
}
if let Some(var_269) = &input.data_access_role_arn {
object.key("DataAccessRoleArn").string(var_269.as_str());
}
if let Some(var_270) = &input.job_name {
object.key("JobName").string(var_270.as_str());
}
if let Some(var_271) = &input.language_code {
object.key("LanguageCode").string(var_271.as_str());
}
if let Some(var_272) = &input.client_request_token {
object.key("ClientRequestToken").string(var_272.as_str());
}
if let Some(var_273) = &input.volume_kms_key_id {
object.key("VolumeKmsKeyId").string(var_273.as_str());
}
if let Some(var_274) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_275 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_275, var_274)?;
object_275.finish();
}
if let Some(var_276) = &input.tags {
let mut array_277 = object.key("Tags").start_array();
for item_278 in var_276 {
{
#[allow(unused_mut)]
let mut object_279 = array_277.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_279, item_278)?;
object_279.finish();
}
}
array_277.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_targeted_sentiment_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartTargetedSentimentDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_280) = &input.input_data_config {
#[allow(unused_mut)]
let mut object_281 = object.key("InputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_input_data_config(
&mut object_281,
var_280,
)?;
object_281.finish();
}
if let Some(var_282) = &input.output_data_config {
#[allow(unused_mut)]
let mut object_283 = object.key("OutputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_output_data_config(
&mut object_283,
var_282,
)?;
object_283.finish();
}
if let Some(var_284) = &input.data_access_role_arn {
object.key("DataAccessRoleArn").string(var_284.as_str());
}
if let Some(var_285) = &input.job_name {
object.key("JobName").string(var_285.as_str());
}
if let Some(var_286) = &input.language_code {
object.key("LanguageCode").string(var_286.as_str());
}
if let Some(var_287) = &input.client_request_token {
object.key("ClientRequestToken").string(var_287.as_str());
}
if let Some(var_288) = &input.volume_kms_key_id {
object.key("VolumeKmsKeyId").string(var_288.as_str());
}
if let Some(var_289) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_290 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_290, var_289)?;
object_290.finish();
}
if let Some(var_291) = &input.tags {
let mut array_292 = object.key("Tags").start_array();
for item_293 in var_291 {
{
#[allow(unused_mut)]
let mut object_294 = array_292.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_294, item_293)?;
object_294.finish();
}
}
array_292.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_topics_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartTopicsDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_295) = &input.input_data_config {
#[allow(unused_mut)]
let mut object_296 = object.key("InputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_input_data_config(
&mut object_296,
var_295,
)?;
object_296.finish();
}
if let Some(var_297) = &input.output_data_config {
#[allow(unused_mut)]
let mut object_298 = object.key("OutputDataConfig").start_object();
crate::json_ser::serialize_structure_crate_model_output_data_config(
&mut object_298,
var_297,
)?;
object_298.finish();
}
if let Some(var_299) = &input.data_access_role_arn {
object.key("DataAccessRoleArn").string(var_299.as_str());
}
if let Some(var_300) = &input.job_name {
object.key("JobName").string(var_300.as_str());
}
if let Some(var_301) = &input.number_of_topics {
object.key("NumberOfTopics").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_301).into()),
);
}
if let Some(var_302) = &input.client_request_token {
object.key("ClientRequestToken").string(var_302.as_str());
}
if let Some(var_303) = &input.volume_kms_key_id {
object.key("VolumeKmsKeyId").string(var_303.as_str());
}
if let Some(var_304) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_305 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_305, var_304)?;
object_305.finish();
}
if let Some(var_306) = &input.tags {
let mut array_307 = object.key("Tags").start_array();
for item_308 in var_306 {
{
#[allow(unused_mut)]
let mut object_309 = array_307.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_309, item_308)?;
object_309.finish();
}
}
array_307.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_dominant_language_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopDominantLanguageDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_310) = &input.job_id {
object.key("JobId").string(var_310.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_entities_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopEntitiesDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_311) = &input.job_id {
object.key("JobId").string(var_311.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_events_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopEventsDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_312) = &input.job_id {
object.key("JobId").string(var_312.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_key_phrases_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopKeyPhrasesDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_313) = &input.job_id {
object.key("JobId").string(var_313.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_pii_entities_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopPiiEntitiesDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_314) = &input.job_id {
object.key("JobId").string(var_314.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_sentiment_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopSentimentDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_315) = &input.job_id {
object.key("JobId").string(var_315.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_targeted_sentiment_detection_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopTargetedSentimentDetectionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_316) = &input.job_id {
object.key("JobId").string(var_316.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_training_document_classifier_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopTrainingDocumentClassifierInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_317) = &input.document_classifier_arn {
object.key("DocumentClassifierArn").string(var_317.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_training_entity_recognizer_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopTrainingEntityRecognizerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_318) = &input.entity_recognizer_arn {
object.key("EntityRecognizerArn").string(var_318.as_str());
}
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_319) = &input.resource_arn {
object.key("ResourceArn").string(var_319.as_str());
}
if let Some(var_320) = &input.tags {
let mut array_321 = object.key("Tags").start_array();
for item_322 in var_320 {
{
#[allow(unused_mut)]
let mut object_323 = array_321.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_323, item_322)?;
object_323.finish();
}
}
array_321.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_untag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UntagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_324) = &input.resource_arn {
object.key("ResourceArn").string(var_324.as_str());
}
if let Some(var_325) = &input.tag_keys {
let mut array_326 = object.key("TagKeys").start_array();
for item_327 in var_325 {
{
array_326.value().string(item_327.as_str());
}
}
array_326.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateEndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_328) = &input.endpoint_arn {
object.key("EndpointArn").string(var_328.as_str());
}
if let Some(var_329) = &input.desired_model_arn {
object.key("DesiredModelArn").string(var_329.as_str());
}
if let Some(var_330) = &input.desired_inference_units {
object.key("DesiredInferenceUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_330).into()),
);
}
if let Some(var_331) = &input.desired_data_access_role_arn {
object
.key("DesiredDataAccessRoleArn")
.string(var_331.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_document_reader_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DocumentReaderConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_332) = &input.document_read_action {
object.key("DocumentReadAction").string(var_332.as_str());
}
if let Some(var_333) = &input.document_read_mode {
object.key("DocumentReadMode").string(var_333.as_str());
}
if let Some(var_334) = &input.feature_types {
let mut array_335 = object.key("FeatureTypes").start_array();
for item_336 in var_334 {
{
array_335.value().string(item_336.as_str());
}
}
array_335.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_337) = &input.key {
object.key("Key").string(var_337.as_str());
}
if let Some(var_338) = &input.value {
object.key("Value").string(var_338.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_document_classifier_input_data_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DocumentClassifierInputDataConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_339) = &input.data_format {
object.key("DataFormat").string(var_339.as_str());
}
if let Some(var_340) = &input.s3_uri {
object.key("S3Uri").string(var_340.as_str());
}
if let Some(var_341) = &input.test_s3_uri {
object.key("TestS3Uri").string(var_341.as_str());
}
if let Some(var_342) = &input.label_delimiter {
object.key("LabelDelimiter").string(var_342.as_str());
}
if let Some(var_343) = &input.augmented_manifests {
let mut array_344 = object.key("AugmentedManifests").start_array();
for item_345 in var_343 {
{
#[allow(unused_mut)]
let mut object_346 = array_344.value().start_object();
crate::json_ser::serialize_structure_crate_model_augmented_manifests_list_item(
&mut object_346,
item_345,
)?;
object_346.finish();
}
}
array_344.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_document_classifier_output_data_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DocumentClassifierOutputDataConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_347) = &input.s3_uri {
object.key("S3Uri").string(var_347.as_str());
}
if let Some(var_348) = &input.kms_key_id {
object.key("KmsKeyId").string(var_348.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_vpc_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VpcConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_349) = &input.security_group_ids {
let mut array_350 = object.key("SecurityGroupIds").start_array();
for item_351 in var_349 {
{
array_350.value().string(item_351.as_str());
}
}
array_350.finish();
}
if let Some(var_352) = &input.subnets {
let mut array_353 = object.key("Subnets").start_array();
for item_354 in var_352 {
{
array_353.value().string(item_354.as_str());
}
}
array_353.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_entity_recognizer_input_data_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EntityRecognizerInputDataConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_355) = &input.data_format {
object.key("DataFormat").string(var_355.as_str());
}
if let Some(var_356) = &input.entity_types {
let mut array_357 = object.key("EntityTypes").start_array();
for item_358 in var_356 {
{
#[allow(unused_mut)]
let mut object_359 = array_357.value().start_object();
crate::json_ser::serialize_structure_crate_model_entity_types_list_item(
&mut object_359,
item_358,
)?;
object_359.finish();
}
}
array_357.finish();
}
if let Some(var_360) = &input.documents {
#[allow(unused_mut)]
let mut object_361 = object.key("Documents").start_object();
crate::json_ser::serialize_structure_crate_model_entity_recognizer_documents(
&mut object_361,
var_360,
)?;
object_361.finish();
}
if let Some(var_362) = &input.annotations {
#[allow(unused_mut)]
let mut object_363 = object.key("Annotations").start_object();
crate::json_ser::serialize_structure_crate_model_entity_recognizer_annotations(
&mut object_363,
var_362,
)?;
object_363.finish();
}
if let Some(var_364) = &input.entity_list {
#[allow(unused_mut)]
let mut object_365 = object.key("EntityList").start_object();
crate::json_ser::serialize_structure_crate_model_entity_recognizer_entity_list(
&mut object_365,
var_364,
)?;
object_365.finish();
}
if let Some(var_366) = &input.augmented_manifests {
let mut array_367 = object.key("AugmentedManifests").start_array();
for item_368 in var_366 {
{
#[allow(unused_mut)]
let mut object_369 = array_367.value().start_object();
crate::json_ser::serialize_structure_crate_model_augmented_manifests_list_item(
&mut object_369,
item_368,
)?;
object_369.finish();
}
}
array_367.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_document_classification_job_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DocumentClassificationJobFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_370) = &input.job_name {
object.key("JobName").string(var_370.as_str());
}
if let Some(var_371) = &input.job_status {
object.key("JobStatus").string(var_371.as_str());
}
if let Some(var_372) = &input.submit_time_before {
object
.key("SubmitTimeBefore")
.date_time(var_372, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_373) = &input.submit_time_after {
object
.key("SubmitTimeAfter")
.date_time(var_373, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_document_classifier_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DocumentClassifierFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_374) = &input.status {
object.key("Status").string(var_374.as_str());
}
if let Some(var_375) = &input.document_classifier_name {
object
.key("DocumentClassifierName")
.string(var_375.as_str());
}
if let Some(var_376) = &input.submit_time_before {
object
.key("SubmitTimeBefore")
.date_time(var_376, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_377) = &input.submit_time_after {
object
.key("SubmitTimeAfter")
.date_time(var_377, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_dominant_language_detection_job_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DominantLanguageDetectionJobFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_378) = &input.job_name {
object.key("JobName").string(var_378.as_str());
}
if let Some(var_379) = &input.job_status {
object.key("JobStatus").string(var_379.as_str());
}
if let Some(var_380) = &input.submit_time_before {
object
.key("SubmitTimeBefore")
.date_time(var_380, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_381) = &input.submit_time_after {
object
.key("SubmitTimeAfter")
.date_time(var_381, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_endpoint_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EndpointFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_382) = &input.model_arn {
object.key("ModelArn").string(var_382.as_str());
}
if let Some(var_383) = &input.status {
object.key("Status").string(var_383.as_str());
}
if let Some(var_384) = &input.creation_time_before {
object
.key("CreationTimeBefore")
.date_time(var_384, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_385) = &input.creation_time_after {
object
.key("CreationTimeAfter")
.date_time(var_385, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_entities_detection_job_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EntitiesDetectionJobFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_386) = &input.job_name {
object.key("JobName").string(var_386.as_str());
}
if let Some(var_387) = &input.job_status {
object.key("JobStatus").string(var_387.as_str());
}
if let Some(var_388) = &input.submit_time_before {
object
.key("SubmitTimeBefore")
.date_time(var_388, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_389) = &input.submit_time_after {
object
.key("SubmitTimeAfter")
.date_time(var_389, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_entity_recognizer_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EntityRecognizerFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_390) = &input.status {
object.key("Status").string(var_390.as_str());
}
if let Some(var_391) = &input.recognizer_name {
object.key("RecognizerName").string(var_391.as_str());
}
if let Some(var_392) = &input.submit_time_before {
object
.key("SubmitTimeBefore")
.date_time(var_392, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_393) = &input.submit_time_after {
object
.key("SubmitTimeAfter")
.date_time(var_393, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_events_detection_job_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EventsDetectionJobFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_394) = &input.job_name {
object.key("JobName").string(var_394.as_str());
}
if let Some(var_395) = &input.job_status {
object.key("JobStatus").string(var_395.as_str());
}
if let Some(var_396) = &input.submit_time_before {
object
.key("SubmitTimeBefore")
.date_time(var_396, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_397) = &input.submit_time_after {
object
.key("SubmitTimeAfter")
.date_time(var_397, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_key_phrases_detection_job_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KeyPhrasesDetectionJobFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_398) = &input.job_name {
object.key("JobName").string(var_398.as_str());
}
if let Some(var_399) = &input.job_status {
object.key("JobStatus").string(var_399.as_str());
}
if let Some(var_400) = &input.submit_time_before {
object
.key("SubmitTimeBefore")
.date_time(var_400, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_401) = &input.submit_time_after {
object
.key("SubmitTimeAfter")
.date_time(var_401, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_pii_entities_detection_job_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PiiEntitiesDetectionJobFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_402) = &input.job_name {
object.key("JobName").string(var_402.as_str());
}
if let Some(var_403) = &input.job_status {
object.key("JobStatus").string(var_403.as_str());
}
if let Some(var_404) = &input.submit_time_before {
object
.key("SubmitTimeBefore")
.date_time(var_404, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_405) = &input.submit_time_after {
object
.key("SubmitTimeAfter")
.date_time(var_405, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_sentiment_detection_job_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SentimentDetectionJobFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_406) = &input.job_name {
object.key("JobName").string(var_406.as_str());
}
if let Some(var_407) = &input.job_status {
object.key("JobStatus").string(var_407.as_str());
}
if let Some(var_408) = &input.submit_time_before {
object
.key("SubmitTimeBefore")
.date_time(var_408, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_409) = &input.submit_time_after {
object
.key("SubmitTimeAfter")
.date_time(var_409, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_targeted_sentiment_detection_job_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TargetedSentimentDetectionJobFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_410) = &input.job_name {
object.key("JobName").string(var_410.as_str());
}
if let Some(var_411) = &input.job_status {
object.key("JobStatus").string(var_411.as_str());
}
if let Some(var_412) = &input.submit_time_before {
object
.key("SubmitTimeBefore")
.date_time(var_412, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_413) = &input.submit_time_after {
object
.key("SubmitTimeAfter")
.date_time(var_413, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_topics_detection_job_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TopicsDetectionJobFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_414) = &input.job_name {
object.key("JobName").string(var_414.as_str());
}
if let Some(var_415) = &input.job_status {
object.key("JobStatus").string(var_415.as_str());
}
if let Some(var_416) = &input.submit_time_before {
object
.key("SubmitTimeBefore")
.date_time(var_416, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_417) = &input.submit_time_after {
object
.key("SubmitTimeAfter")
.date_time(var_417, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_input_data_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InputDataConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_418) = &input.s3_uri {
object.key("S3Uri").string(var_418.as_str());
}
if let Some(var_419) = &input.input_format {
object.key("InputFormat").string(var_419.as_str());
}
if let Some(var_420) = &input.document_reader_config {
#[allow(unused_mut)]
let mut object_421 = object.key("DocumentReaderConfig").start_object();
crate::json_ser::serialize_structure_crate_model_document_reader_config(
&mut object_421,
var_420,
)?;
object_421.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_output_data_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OutputDataConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_422) = &input.s3_uri {
object.key("S3Uri").string(var_422.as_str());
}
if let Some(var_423) = &input.kms_key_id {
object.key("KmsKeyId").string(var_423.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_redaction_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RedactionConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_424) = &input.pii_entity_types {
let mut array_425 = object.key("PiiEntityTypes").start_array();
for item_426 in var_424 {
{
array_425.value().string(item_426.as_str());
}
}
array_425.finish();
}
if let Some(var_427) = &input.mask_mode {
object.key("MaskMode").string(var_427.as_str());
}
if let Some(var_428) = &input.mask_character {
object.key("MaskCharacter").string(var_428.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_augmented_manifests_list_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AugmentedManifestsListItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_429) = &input.s3_uri {
object.key("S3Uri").string(var_429.as_str());
}
if let Some(var_430) = &input.split {
object.key("Split").string(var_430.as_str());
}
if let Some(var_431) = &input.attribute_names {
let mut array_432 = object.key("AttributeNames").start_array();
for item_433 in var_431 {
{
array_432.value().string(item_433.as_str());
}
}
array_432.finish();
}
if let Some(var_434) = &input.annotation_data_s3_uri {
object.key("AnnotationDataS3Uri").string(var_434.as_str());
}
if let Some(var_435) = &input.source_documents_s3_uri {
object.key("SourceDocumentsS3Uri").string(var_435.as_str());
}
if let Some(var_436) = &input.document_type {
object.key("DocumentType").string(var_436.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_entity_types_list_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EntityTypesListItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_437) = &input.r#type {
object.key("Type").string(var_437.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_entity_recognizer_documents(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EntityRecognizerDocuments,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_438) = &input.s3_uri {
object.key("S3Uri").string(var_438.as_str());
}
if let Some(var_439) = &input.test_s3_uri {
object.key("TestS3Uri").string(var_439.as_str());
}
if let Some(var_440) = &input.input_format {
object.key("InputFormat").string(var_440.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_entity_recognizer_annotations(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EntityRecognizerAnnotations,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_441) = &input.s3_uri {
object.key("S3Uri").string(var_441.as_str());
}
if let Some(var_442) = &input.test_s3_uri {
object.key("TestS3Uri").string(var_442.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_entity_recognizer_entity_list(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EntityRecognizerEntityList,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_443) = &input.s3_uri {
object.key("S3Uri").string(var_443.as_str());
}
Ok(())
}