json_ser.rs

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
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::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);
            }
        }
        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::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);
            }
        }
        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::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);
            }
        }
        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::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);
            }
        }
        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::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);
            }
        }
        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_classify_document_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ClassifyDocumentInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_20) = &input.text {
        object.key("Text").string(var_20);
    }
    if let Some(var_21) = &input.endpoint_arn {
        object.key("EndpointArn").string(var_21);
    }
    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::SerializationError> {
    if let Some(var_22) = &input.text {
        object.key("Text").string(var_22);
    }
    if let Some(var_23) = &input.language_code {
        object.key("LanguageCode").string(var_23.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::SerializationError> {
    if let Some(var_24) = &input.document_classifier_name {
        object.key("DocumentClassifierName").string(var_24);
    }
    if let Some(var_25) = &input.version_name {
        object.key("VersionName").string(var_25);
    }
    if let Some(var_26) = &input.data_access_role_arn {
        object.key("DataAccessRoleArn").string(var_26);
    }
    if let Some(var_27) = &input.tags {
        let mut array_28 = object.key("Tags").start_array();
        for item_29 in var_27 {
            {
                let mut object_30 = array_28.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_30, item_29)?;
                object_30.finish();
            }
        }
        array_28.finish();
    }
    if let Some(var_31) = &input.input_data_config {
        let mut object_32 = object.key("InputDataConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_document_classifier_input_data_config(
            &mut object_32,
            var_31,
        )?;
        object_32.finish();
    }
    if let Some(var_33) = &input.output_data_config {
        let mut object_34 = object.key("OutputDataConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_document_classifier_output_data_config(
            &mut object_34,
            var_33,
        )?;
        object_34.finish();
    }
    if let Some(var_35) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_35);
    }
    if let Some(var_36) = &input.language_code {
        object.key("LanguageCode").string(var_36.as_str());
    }
    if let Some(var_37) = &input.volume_kms_key_id {
        object.key("VolumeKmsKeyId").string(var_37);
    }
    if let Some(var_38) = &input.vpc_config {
        let mut object_39 = object.key("VpcConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_39, var_38)?;
        object_39.finish();
    }
    if let Some(var_40) = &input.mode {
        object.key("Mode").string(var_40.as_str());
    }
    if let Some(var_41) = &input.model_kms_key_id {
        object.key("ModelKmsKeyId").string(var_41);
    }
    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::SerializationError> {
    if let Some(var_42) = &input.endpoint_name {
        object.key("EndpointName").string(var_42);
    }
    if let Some(var_43) = &input.model_arn {
        object.key("ModelArn").string(var_43);
    }
    if let Some(var_44) = &input.desired_inference_units {
        object.key("DesiredInferenceUnits").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_44).into()),
        );
    }
    if let Some(var_45) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_45);
    }
    if let Some(var_46) = &input.tags {
        let mut array_47 = object.key("Tags").start_array();
        for item_48 in var_46 {
            {
                let mut object_49 = array_47.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_49, item_48)?;
                object_49.finish();
            }
        }
        array_47.finish();
    }
    if let Some(var_50) = &input.data_access_role_arn {
        object.key("DataAccessRoleArn").string(var_50);
    }
    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::SerializationError> {
    if let Some(var_51) = &input.recognizer_name {
        object.key("RecognizerName").string(var_51);
    }
    if let Some(var_52) = &input.version_name {
        object.key("VersionName").string(var_52);
    }
    if let Some(var_53) = &input.data_access_role_arn {
        object.key("DataAccessRoleArn").string(var_53);
    }
    if let Some(var_54) = &input.tags {
        let mut array_55 = object.key("Tags").start_array();
        for item_56 in var_54 {
            {
                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.input_data_config {
        let mut object_59 = object.key("InputDataConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_entity_recognizer_input_data_config(
            &mut object_59,
            var_58,
        )?;
        object_59.finish();
    }
    if let Some(var_60) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_60);
    }
    if let Some(var_61) = &input.language_code {
        object.key("LanguageCode").string(var_61.as_str());
    }
    if let Some(var_62) = &input.volume_kms_key_id {
        object.key("VolumeKmsKeyId").string(var_62);
    }
    if let Some(var_63) = &input.vpc_config {
        let mut object_64 = object.key("VpcConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_64, var_63)?;
        object_64.finish();
    }
    if let Some(var_65) = &input.model_kms_key_id {
        object.key("ModelKmsKeyId").string(var_65);
    }
    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::SerializationError> {
    if let Some(var_66) = &input.document_classifier_arn {
        object.key("DocumentClassifierArn").string(var_66);
    }
    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::SerializationError> {
    if let Some(var_67) = &input.endpoint_arn {
        object.key("EndpointArn").string(var_67);
    }
    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::SerializationError> {
    if let Some(var_68) = &input.entity_recognizer_arn {
        object.key("EntityRecognizerArn").string(var_68);
    }
    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::SerializationError> {
    if let Some(var_69) = &input.job_id {
        object.key("JobId").string(var_69);
    }
    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::SerializationError> {
    if let Some(var_70) = &input.document_classifier_arn {
        object.key("DocumentClassifierArn").string(var_70);
    }
    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::SerializationError> {
    if let Some(var_71) = &input.job_id {
        object.key("JobId").string(var_71);
    }
    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::SerializationError> {
    if let Some(var_72) = &input.endpoint_arn {
        object.key("EndpointArn").string(var_72);
    }
    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::SerializationError> {
    if let Some(var_73) = &input.job_id {
        object.key("JobId").string(var_73);
    }
    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::SerializationError> {
    if let Some(var_74) = &input.entity_recognizer_arn {
        object.key("EntityRecognizerArn").string(var_74);
    }
    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::SerializationError> {
    if let Some(var_75) = &input.job_id {
        object.key("JobId").string(var_75);
    }
    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::SerializationError> {
    if let Some(var_76) = &input.job_id {
        object.key("JobId").string(var_76);
    }
    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::SerializationError> {
    if let Some(var_77) = &input.job_id {
        object.key("JobId").string(var_77);
    }
    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::SerializationError> {
    if let Some(var_78) = &input.job_id {
        object.key("JobId").string(var_78);
    }
    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::SerializationError> {
    if let Some(var_79) = &input.job_id {
        object.key("JobId").string(var_79);
    }
    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::SerializationError> {
    if let Some(var_80) = &input.text {
        object.key("Text").string(var_80);
    }
    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::SerializationError> {
    if let Some(var_81) = &input.text {
        object.key("Text").string(var_81);
    }
    if let Some(var_82) = &input.language_code {
        object.key("LanguageCode").string(var_82.as_str());
    }
    if let Some(var_83) = &input.endpoint_arn {
        object.key("EndpointArn").string(var_83);
    }
    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::SerializationError> {
    if let Some(var_84) = &input.text {
        object.key("Text").string(var_84);
    }
    if let Some(var_85) = &input.language_code {
        object.key("LanguageCode").string(var_85.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::SerializationError> {
    if let Some(var_86) = &input.text {
        object.key("Text").string(var_86);
    }
    if let Some(var_87) = &input.language_code {
        object.key("LanguageCode").string(var_87.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::SerializationError> {
    if let Some(var_88) = &input.text {
        object.key("Text").string(var_88);
    }
    if let Some(var_89) = &input.language_code {
        object.key("LanguageCode").string(var_89.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::SerializationError> {
    if let Some(var_90) = &input.text {
        object.key("Text").string(var_90);
    }
    if let Some(var_91) = &input.language_code {
        object.key("LanguageCode").string(var_91.as_str());
    }
    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::SerializationError> {
    if let Some(var_92) = &input.filter {
        let mut object_93 = object.key("Filter").start_object();
        crate::json_ser::serialize_structure_crate_model_document_classification_job_filter(
            &mut object_93,
            var_92,
        )?;
        object_93.finish();
    }
    if let Some(var_94) = &input.next_token {
        object.key("NextToken").string(var_94);
    }
    if let Some(var_95) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_95).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::SerializationError> {
    if let Some(var_96) = &input.filter {
        let mut object_97 = object.key("Filter").start_object();
        crate::json_ser::serialize_structure_crate_model_document_classifier_filter(
            &mut object_97,
            var_96,
        )?;
        object_97.finish();
    }
    if let Some(var_98) = &input.next_token {
        object.key("NextToken").string(var_98);
    }
    if let Some(var_99) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_99).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::SerializationError> {
    if let Some(var_100) = &input.next_token {
        object.key("NextToken").string(var_100);
    }
    if let Some(var_101) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_101).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::SerializationError> {
    if let Some(var_102) = &input.filter {
        let mut object_103 = object.key("Filter").start_object();
        crate::json_ser::serialize_structure_crate_model_dominant_language_detection_job_filter(
            &mut object_103,
            var_102,
        )?;
        object_103.finish();
    }
    if let Some(var_104) = &input.next_token {
        object.key("NextToken").string(var_104);
    }
    if let Some(var_105) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_105).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::SerializationError> {
    if let Some(var_106) = &input.filter {
        let mut object_107 = object.key("Filter").start_object();
        crate::json_ser::serialize_structure_crate_model_endpoint_filter(&mut object_107, var_106)?;
        object_107.finish();
    }
    if let Some(var_108) = &input.next_token {
        object.key("NextToken").string(var_108);
    }
    if let Some(var_109) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_109).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::SerializationError> {
    if let Some(var_110) = &input.filter {
        let mut object_111 = object.key("Filter").start_object();
        crate::json_ser::serialize_structure_crate_model_entities_detection_job_filter(
            &mut object_111,
            var_110,
        )?;
        object_111.finish();
    }
    if let Some(var_112) = &input.next_token {
        object.key("NextToken").string(var_112);
    }
    if let Some(var_113) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_113).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::SerializationError> {
    if let Some(var_114) = &input.filter {
        let mut object_115 = object.key("Filter").start_object();
        crate::json_ser::serialize_structure_crate_model_entity_recognizer_filter(
            &mut object_115,
            var_114,
        )?;
        object_115.finish();
    }
    if let Some(var_116) = &input.next_token {
        object.key("NextToken").string(var_116);
    }
    if let Some(var_117) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_117).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::SerializationError> {
    if let Some(var_118) = &input.next_token {
        object.key("NextToken").string(var_118);
    }
    if let Some(var_119) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_119).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::SerializationError> {
    if let Some(var_120) = &input.filter {
        let mut object_121 = object.key("Filter").start_object();
        crate::json_ser::serialize_structure_crate_model_events_detection_job_filter(
            &mut object_121,
            var_120,
        )?;
        object_121.finish();
    }
    if let Some(var_122) = &input.next_token {
        object.key("NextToken").string(var_122);
    }
    if let Some(var_123) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_123).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::SerializationError> {
    if let Some(var_124) = &input.filter {
        let mut object_125 = object.key("Filter").start_object();
        crate::json_ser::serialize_structure_crate_model_key_phrases_detection_job_filter(
            &mut object_125,
            var_124,
        )?;
        object_125.finish();
    }
    if let Some(var_126) = &input.next_token {
        object.key("NextToken").string(var_126);
    }
    if let Some(var_127) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_127).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::SerializationError> {
    if let Some(var_128) = &input.filter {
        let mut object_129 = object.key("Filter").start_object();
        crate::json_ser::serialize_structure_crate_model_pii_entities_detection_job_filter(
            &mut object_129,
            var_128,
        )?;
        object_129.finish();
    }
    if let Some(var_130) = &input.next_token {
        object.key("NextToken").string(var_130);
    }
    if let Some(var_131) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_131).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::SerializationError> {
    if let Some(var_132) = &input.filter {
        let mut object_133 = object.key("Filter").start_object();
        crate::json_ser::serialize_structure_crate_model_sentiment_detection_job_filter(
            &mut object_133,
            var_132,
        )?;
        object_133.finish();
    }
    if let Some(var_134) = &input.next_token {
        object.key("NextToken").string(var_134);
    }
    if let Some(var_135) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_135).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::SerializationError> {
    if let Some(var_136) = &input.resource_arn {
        object.key("ResourceArn").string(var_136);
    }
    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::SerializationError> {
    if let Some(var_137) = &input.filter {
        let mut object_138 = object.key("Filter").start_object();
        crate::json_ser::serialize_structure_crate_model_topics_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);
    }
    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_start_document_classification_job_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StartDocumentClassificationJobInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_141) = &input.job_name {
        object.key("JobName").string(var_141);
    }
    if let Some(var_142) = &input.document_classifier_arn {
        object.key("DocumentClassifierArn").string(var_142);
    }
    if let Some(var_143) = &input.input_data_config {
        let mut object_144 = object.key("InputDataConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_input_data_config(
            &mut object_144,
            var_143,
        )?;
        object_144.finish();
    }
    if let Some(var_145) = &input.output_data_config {
        let mut object_146 = object.key("OutputDataConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_output_data_config(
            &mut object_146,
            var_145,
        )?;
        object_146.finish();
    }
    if let Some(var_147) = &input.data_access_role_arn {
        object.key("DataAccessRoleArn").string(var_147);
    }
    if let Some(var_148) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_148);
    }
    if let Some(var_149) = &input.volume_kms_key_id {
        object.key("VolumeKmsKeyId").string(var_149);
    }
    if let Some(var_150) = &input.vpc_config {
        let mut object_151 = object.key("VpcConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_151, var_150)?;
        object_151.finish();
    }
    if let Some(var_152) = &input.tags {
        let mut array_153 = object.key("Tags").start_array();
        for item_154 in var_152 {
            {
                let mut object_155 = array_153.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_155, item_154)?;
                object_155.finish();
            }
        }
        array_153.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::SerializationError> {
    if let Some(var_156) = &input.input_data_config {
        let mut object_157 = object.key("InputDataConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_input_data_config(
            &mut object_157,
            var_156,
        )?;
        object_157.finish();
    }
    if let Some(var_158) = &input.output_data_config {
        let mut object_159 = object.key("OutputDataConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_output_data_config(
            &mut object_159,
            var_158,
        )?;
        object_159.finish();
    }
    if let Some(var_160) = &input.data_access_role_arn {
        object.key("DataAccessRoleArn").string(var_160);
    }
    if let Some(var_161) = &input.job_name {
        object.key("JobName").string(var_161);
    }
    if let Some(var_162) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_162);
    }
    if let Some(var_163) = &input.volume_kms_key_id {
        object.key("VolumeKmsKeyId").string(var_163);
    }
    if let Some(var_164) = &input.vpc_config {
        let mut object_165 = object.key("VpcConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_165, var_164)?;
        object_165.finish();
    }
    if let Some(var_166) = &input.tags {
        let mut array_167 = object.key("Tags").start_array();
        for item_168 in var_166 {
            {
                let mut object_169 = array_167.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_169, item_168)?;
                object_169.finish();
            }
        }
        array_167.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::SerializationError> {
    if let Some(var_170) = &input.input_data_config {
        let mut object_171 = object.key("InputDataConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_input_data_config(
            &mut object_171,
            var_170,
        )?;
        object_171.finish();
    }
    if let Some(var_172) = &input.output_data_config {
        let mut object_173 = object.key("OutputDataConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_output_data_config(
            &mut object_173,
            var_172,
        )?;
        object_173.finish();
    }
    if let Some(var_174) = &input.data_access_role_arn {
        object.key("DataAccessRoleArn").string(var_174);
    }
    if let Some(var_175) = &input.job_name {
        object.key("JobName").string(var_175);
    }
    if let Some(var_176) = &input.entity_recognizer_arn {
        object.key("EntityRecognizerArn").string(var_176);
    }
    if let Some(var_177) = &input.language_code {
        object.key("LanguageCode").string(var_177.as_str());
    }
    if let Some(var_178) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_178);
    }
    if let Some(var_179) = &input.volume_kms_key_id {
        object.key("VolumeKmsKeyId").string(var_179);
    }
    if let Some(var_180) = &input.vpc_config {
        let mut object_181 = object.key("VpcConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_181, var_180)?;
        object_181.finish();
    }
    if let Some(var_182) = &input.tags {
        let mut array_183 = object.key("Tags").start_array();
        for item_184 in var_182 {
            {
                let mut object_185 = array_183.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_185, item_184)?;
                object_185.finish();
            }
        }
        array_183.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::SerializationError> {
    if let Some(var_186) = &input.input_data_config {
        let mut object_187 = object.key("InputDataConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_input_data_config(
            &mut object_187,
            var_186,
        )?;
        object_187.finish();
    }
    if let Some(var_188) = &input.output_data_config {
        let mut object_189 = object.key("OutputDataConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_output_data_config(
            &mut object_189,
            var_188,
        )?;
        object_189.finish();
    }
    if let Some(var_190) = &input.data_access_role_arn {
        object.key("DataAccessRoleArn").string(var_190);
    }
    if let Some(var_191) = &input.job_name {
        object.key("JobName").string(var_191);
    }
    if let Some(var_192) = &input.language_code {
        object.key("LanguageCode").string(var_192.as_str());
    }
    if let Some(var_193) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_193);
    }
    if let Some(var_194) = &input.target_event_types {
        let mut array_195 = object.key("TargetEventTypes").start_array();
        for item_196 in var_194 {
            {
                array_195.value().string(item_196);
            }
        }
        array_195.finish();
    }
    if let Some(var_197) = &input.tags {
        let mut array_198 = object.key("Tags").start_array();
        for item_199 in var_197 {
            {
                let mut object_200 = array_198.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_200, item_199)?;
                object_200.finish();
            }
        }
        array_198.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::SerializationError> {
    if let Some(var_201) = &input.input_data_config {
        let mut object_202 = object.key("InputDataConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_input_data_config(
            &mut object_202,
            var_201,
        )?;
        object_202.finish();
    }
    if let Some(var_203) = &input.output_data_config {
        let mut object_204 = object.key("OutputDataConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_output_data_config(
            &mut object_204,
            var_203,
        )?;
        object_204.finish();
    }
    if let Some(var_205) = &input.data_access_role_arn {
        object.key("DataAccessRoleArn").string(var_205);
    }
    if let Some(var_206) = &input.job_name {
        object.key("JobName").string(var_206);
    }
    if let Some(var_207) = &input.language_code {
        object.key("LanguageCode").string(var_207.as_str());
    }
    if let Some(var_208) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_208);
    }
    if let Some(var_209) = &input.volume_kms_key_id {
        object.key("VolumeKmsKeyId").string(var_209);
    }
    if let Some(var_210) = &input.vpc_config {
        let mut object_211 = object.key("VpcConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_211, var_210)?;
        object_211.finish();
    }
    if let Some(var_212) = &input.tags {
        let mut array_213 = object.key("Tags").start_array();
        for item_214 in var_212 {
            {
                let mut object_215 = array_213.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_215, item_214)?;
                object_215.finish();
            }
        }
        array_213.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::SerializationError> {
    if let Some(var_216) = &input.input_data_config {
        let mut object_217 = object.key("InputDataConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_input_data_config(
            &mut object_217,
            var_216,
        )?;
        object_217.finish();
    }
    if let Some(var_218) = &input.output_data_config {
        let mut object_219 = object.key("OutputDataConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_output_data_config(
            &mut object_219,
            var_218,
        )?;
        object_219.finish();
    }
    if let Some(var_220) = &input.mode {
        object.key("Mode").string(var_220.as_str());
    }
    if let Some(var_221) = &input.redaction_config {
        let mut object_222 = object.key("RedactionConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_redaction_config(
            &mut object_222,
            var_221,
        )?;
        object_222.finish();
    }
    if let Some(var_223) = &input.data_access_role_arn {
        object.key("DataAccessRoleArn").string(var_223);
    }
    if let Some(var_224) = &input.job_name {
        object.key("JobName").string(var_224);
    }
    if let Some(var_225) = &input.language_code {
        object.key("LanguageCode").string(var_225.as_str());
    }
    if let Some(var_226) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_226);
    }
    if let Some(var_227) = &input.tags {
        let mut array_228 = object.key("Tags").start_array();
        for item_229 in var_227 {
            {
                let mut object_230 = array_228.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_230, item_229)?;
                object_230.finish();
            }
        }
        array_228.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::SerializationError> {
    if let Some(var_231) = &input.input_data_config {
        let mut object_232 = object.key("InputDataConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_input_data_config(
            &mut object_232,
            var_231,
        )?;
        object_232.finish();
    }
    if let Some(var_233) = &input.output_data_config {
        let mut object_234 = object.key("OutputDataConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_output_data_config(
            &mut object_234,
            var_233,
        )?;
        object_234.finish();
    }
    if let Some(var_235) = &input.data_access_role_arn {
        object.key("DataAccessRoleArn").string(var_235);
    }
    if let Some(var_236) = &input.job_name {
        object.key("JobName").string(var_236);
    }
    if let Some(var_237) = &input.language_code {
        object.key("LanguageCode").string(var_237.as_str());
    }
    if let Some(var_238) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_238);
    }
    if let Some(var_239) = &input.volume_kms_key_id {
        object.key("VolumeKmsKeyId").string(var_239);
    }
    if let Some(var_240) = &input.vpc_config {
        let mut object_241 = object.key("VpcConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_241, var_240)?;
        object_241.finish();
    }
    if let Some(var_242) = &input.tags {
        let mut array_243 = object.key("Tags").start_array();
        for item_244 in var_242 {
            {
                let mut object_245 = array_243.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_245, item_244)?;
                object_245.finish();
            }
        }
        array_243.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::SerializationError> {
    if let Some(var_246) = &input.input_data_config {
        let mut object_247 = object.key("InputDataConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_input_data_config(
            &mut object_247,
            var_246,
        )?;
        object_247.finish();
    }
    if let Some(var_248) = &input.output_data_config {
        let mut object_249 = object.key("OutputDataConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_output_data_config(
            &mut object_249,
            var_248,
        )?;
        object_249.finish();
    }
    if let Some(var_250) = &input.data_access_role_arn {
        object.key("DataAccessRoleArn").string(var_250);
    }
    if let Some(var_251) = &input.job_name {
        object.key("JobName").string(var_251);
    }
    if let Some(var_252) = &input.number_of_topics {
        object.key("NumberOfTopics").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_252).into()),
        );
    }
    if let Some(var_253) = &input.client_request_token {
        object.key("ClientRequestToken").string(var_253);
    }
    if let Some(var_254) = &input.volume_kms_key_id {
        object.key("VolumeKmsKeyId").string(var_254);
    }
    if let Some(var_255) = &input.vpc_config {
        let mut object_256 = object.key("VpcConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_256, var_255)?;
        object_256.finish();
    }
    if let Some(var_257) = &input.tags {
        let mut array_258 = object.key("Tags").start_array();
        for item_259 in var_257 {
            {
                let mut object_260 = array_258.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_260, item_259)?;
                object_260.finish();
            }
        }
        array_258.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::SerializationError> {
    if let Some(var_261) = &input.job_id {
        object.key("JobId").string(var_261);
    }
    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::SerializationError> {
    if let Some(var_262) = &input.job_id {
        object.key("JobId").string(var_262);
    }
    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::SerializationError> {
    if let Some(var_263) = &input.job_id {
        object.key("JobId").string(var_263);
    }
    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::SerializationError> {
    if let Some(var_264) = &input.job_id {
        object.key("JobId").string(var_264);
    }
    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::SerializationError> {
    if let Some(var_265) = &input.job_id {
        object.key("JobId").string(var_265);
    }
    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::SerializationError> {
    if let Some(var_266) = &input.job_id {
        object.key("JobId").string(var_266);
    }
    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::SerializationError> {
    if let Some(var_267) = &input.document_classifier_arn {
        object.key("DocumentClassifierArn").string(var_267);
    }
    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::SerializationError> {
    if let Some(var_268) = &input.entity_recognizer_arn {
        object.key("EntityRecognizerArn").string(var_268);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_tag_resource_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_269) = &input.resource_arn {
        object.key("ResourceArn").string(var_269);
    }
    if let Some(var_270) = &input.tags {
        let mut array_271 = object.key("Tags").start_array();
        for item_272 in var_270 {
            {
                let mut object_273 = array_271.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_273, item_272)?;
                object_273.finish();
            }
        }
        array_271.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::SerializationError> {
    if let Some(var_274) = &input.resource_arn {
        object.key("ResourceArn").string(var_274);
    }
    if let Some(var_275) = &input.tag_keys {
        let mut array_276 = object.key("TagKeys").start_array();
        for item_277 in var_275 {
            {
                array_276.value().string(item_277);
            }
        }
        array_276.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::SerializationError> {
    if let Some(var_278) = &input.endpoint_arn {
        object.key("EndpointArn").string(var_278);
    }
    if let Some(var_279) = &input.desired_model_arn {
        object.key("DesiredModelArn").string(var_279);
    }
    if let Some(var_280) = &input.desired_inference_units {
        object.key("DesiredInferenceUnits").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_280).into()),
        );
    }
    if let Some(var_281) = &input.desired_data_access_role_arn {
        object.key("DesiredDataAccessRoleArn").string(var_281);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_tag(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_282) = &input.key {
        object.key("Key").string(var_282);
    }
    if let Some(var_283) = &input.value {
        object.key("Value").string(var_283);
    }
    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::SerializationError> {
    if let Some(var_284) = &input.data_format {
        object.key("DataFormat").string(var_284.as_str());
    }
    if let Some(var_285) = &input.s3_uri {
        object.key("S3Uri").string(var_285);
    }
    if let Some(var_286) = &input.test_s3_uri {
        object.key("TestS3Uri").string(var_286);
    }
    if let Some(var_287) = &input.label_delimiter {
        object.key("LabelDelimiter").string(var_287);
    }
    if let Some(var_288) = &input.augmented_manifests {
        let mut array_289 = object.key("AugmentedManifests").start_array();
        for item_290 in var_288 {
            {
                let mut object_291 = array_289.value().start_object();
                crate::json_ser::serialize_structure_crate_model_augmented_manifests_list_item(
                    &mut object_291,
                    item_290,
                )?;
                object_291.finish();
            }
        }
        array_289.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::SerializationError> {
    if let Some(var_292) = &input.s3_uri {
        object.key("S3Uri").string(var_292);
    }
    if let Some(var_293) = &input.kms_key_id {
        object.key("KmsKeyId").string(var_293);
    }
    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::SerializationError> {
    if let Some(var_294) = &input.security_group_ids {
        let mut array_295 = object.key("SecurityGroupIds").start_array();
        for item_296 in var_294 {
            {
                array_295.value().string(item_296);
            }
        }
        array_295.finish();
    }
    if let Some(var_297) = &input.subnets {
        let mut array_298 = object.key("Subnets").start_array();
        for item_299 in var_297 {
            {
                array_298.value().string(item_299);
            }
        }
        array_298.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::SerializationError> {
    if let Some(var_300) = &input.data_format {
        object.key("DataFormat").string(var_300.as_str());
    }
    if let Some(var_301) = &input.entity_types {
        let mut array_302 = object.key("EntityTypes").start_array();
        for item_303 in var_301 {
            {
                let mut object_304 = array_302.value().start_object();
                crate::json_ser::serialize_structure_crate_model_entity_types_list_item(
                    &mut object_304,
                    item_303,
                )?;
                object_304.finish();
            }
        }
        array_302.finish();
    }
    if let Some(var_305) = &input.documents {
        let mut object_306 = object.key("Documents").start_object();
        crate::json_ser::serialize_structure_crate_model_entity_recognizer_documents(
            &mut object_306,
            var_305,
        )?;
        object_306.finish();
    }
    if let Some(var_307) = &input.annotations {
        let mut object_308 = object.key("Annotations").start_object();
        crate::json_ser::serialize_structure_crate_model_entity_recognizer_annotations(
            &mut object_308,
            var_307,
        )?;
        object_308.finish();
    }
    if let Some(var_309) = &input.entity_list {
        let mut object_310 = object.key("EntityList").start_object();
        crate::json_ser::serialize_structure_crate_model_entity_recognizer_entity_list(
            &mut object_310,
            var_309,
        )?;
        object_310.finish();
    }
    if let Some(var_311) = &input.augmented_manifests {
        let mut array_312 = object.key("AugmentedManifests").start_array();
        for item_313 in var_311 {
            {
                let mut object_314 = array_312.value().start_object();
                crate::json_ser::serialize_structure_crate_model_augmented_manifests_list_item(
                    &mut object_314,
                    item_313,
                )?;
                object_314.finish();
            }
        }
        array_312.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::SerializationError> {
    if let Some(var_315) = &input.job_name {
        object.key("JobName").string(var_315);
    }
    if let Some(var_316) = &input.job_status {
        object.key("JobStatus").string(var_316.as_str());
    }
    if let Some(var_317) = &input.submit_time_before {
        object
            .key("SubmitTimeBefore")
            .date_time(var_317, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    if let Some(var_318) = &input.submit_time_after {
        object
            .key("SubmitTimeAfter")
            .date_time(var_318, 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::SerializationError> {
    if let Some(var_319) = &input.status {
        object.key("Status").string(var_319.as_str());
    }
    if let Some(var_320) = &input.document_classifier_name {
        object.key("DocumentClassifierName").string(var_320);
    }
    if let Some(var_321) = &input.submit_time_before {
        object
            .key("SubmitTimeBefore")
            .date_time(var_321, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    if let Some(var_322) = &input.submit_time_after {
        object
            .key("SubmitTimeAfter")
            .date_time(var_322, 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::SerializationError> {
    if let Some(var_323) = &input.job_name {
        object.key("JobName").string(var_323);
    }
    if let Some(var_324) = &input.job_status {
        object.key("JobStatus").string(var_324.as_str());
    }
    if let Some(var_325) = &input.submit_time_before {
        object
            .key("SubmitTimeBefore")
            .date_time(var_325, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    if let Some(var_326) = &input.submit_time_after {
        object
            .key("SubmitTimeAfter")
            .date_time(var_326, 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::SerializationError> {
    if let Some(var_327) = &input.model_arn {
        object.key("ModelArn").string(var_327);
    }
    if let Some(var_328) = &input.status {
        object.key("Status").string(var_328.as_str());
    }
    if let Some(var_329) = &input.creation_time_before {
        object
            .key("CreationTimeBefore")
            .date_time(var_329, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    if let Some(var_330) = &input.creation_time_after {
        object
            .key("CreationTimeAfter")
            .date_time(var_330, 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::SerializationError> {
    if let Some(var_331) = &input.job_name {
        object.key("JobName").string(var_331);
    }
    if let Some(var_332) = &input.job_status {
        object.key("JobStatus").string(var_332.as_str());
    }
    if let Some(var_333) = &input.submit_time_before {
        object
            .key("SubmitTimeBefore")
            .date_time(var_333, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    if let Some(var_334) = &input.submit_time_after {
        object
            .key("SubmitTimeAfter")
            .date_time(var_334, 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::SerializationError> {
    if let Some(var_335) = &input.status {
        object.key("Status").string(var_335.as_str());
    }
    if let Some(var_336) = &input.recognizer_name {
        object.key("RecognizerName").string(var_336);
    }
    if let Some(var_337) = &input.submit_time_before {
        object
            .key("SubmitTimeBefore")
            .date_time(var_337, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    if let Some(var_338) = &input.submit_time_after {
        object
            .key("SubmitTimeAfter")
            .date_time(var_338, 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::SerializationError> {
    if let Some(var_339) = &input.job_name {
        object.key("JobName").string(var_339);
    }
    if let Some(var_340) = &input.job_status {
        object.key("JobStatus").string(var_340.as_str());
    }
    if let Some(var_341) = &input.submit_time_before {
        object
            .key("SubmitTimeBefore")
            .date_time(var_341, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    if let Some(var_342) = &input.submit_time_after {
        object
            .key("SubmitTimeAfter")
            .date_time(var_342, 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::SerializationError> {
    if let Some(var_343) = &input.job_name {
        object.key("JobName").string(var_343);
    }
    if let Some(var_344) = &input.job_status {
        object.key("JobStatus").string(var_344.as_str());
    }
    if let Some(var_345) = &input.submit_time_before {
        object
            .key("SubmitTimeBefore")
            .date_time(var_345, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    if let Some(var_346) = &input.submit_time_after {
        object
            .key("SubmitTimeAfter")
            .date_time(var_346, 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::SerializationError> {
    if let Some(var_347) = &input.job_name {
        object.key("JobName").string(var_347);
    }
    if let Some(var_348) = &input.job_status {
        object.key("JobStatus").string(var_348.as_str());
    }
    if let Some(var_349) = &input.submit_time_before {
        object
            .key("SubmitTimeBefore")
            .date_time(var_349, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    if let Some(var_350) = &input.submit_time_after {
        object
            .key("SubmitTimeAfter")
            .date_time(var_350, 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::SerializationError> {
    if let Some(var_351) = &input.job_name {
        object.key("JobName").string(var_351);
    }
    if let Some(var_352) = &input.job_status {
        object.key("JobStatus").string(var_352.as_str());
    }
    if let Some(var_353) = &input.submit_time_before {
        object
            .key("SubmitTimeBefore")
            .date_time(var_353, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    if let Some(var_354) = &input.submit_time_after {
        object
            .key("SubmitTimeAfter")
            .date_time(var_354, 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::SerializationError> {
    if let Some(var_355) = &input.job_name {
        object.key("JobName").string(var_355);
    }
    if let Some(var_356) = &input.job_status {
        object.key("JobStatus").string(var_356.as_str());
    }
    if let Some(var_357) = &input.submit_time_before {
        object
            .key("SubmitTimeBefore")
            .date_time(var_357, aws_smithy_types::date_time::Format::EpochSeconds)?;
    }
    if let Some(var_358) = &input.submit_time_after {
        object
            .key("SubmitTimeAfter")
            .date_time(var_358, 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::SerializationError> {
    if let Some(var_359) = &input.s3_uri {
        object.key("S3Uri").string(var_359);
    }
    if let Some(var_360) = &input.input_format {
        object.key("InputFormat").string(var_360.as_str());
    }
    if let Some(var_361) = &input.document_reader_config {
        let mut object_362 = object.key("DocumentReaderConfig").start_object();
        crate::json_ser::serialize_structure_crate_model_document_reader_config(
            &mut object_362,
            var_361,
        )?;
        object_362.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::SerializationError> {
    if let Some(var_363) = &input.s3_uri {
        object.key("S3Uri").string(var_363);
    }
    if let Some(var_364) = &input.kms_key_id {
        object.key("KmsKeyId").string(var_364);
    }
    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::SerializationError> {
    if let Some(var_365) = &input.pii_entity_types {
        let mut array_366 = object.key("PiiEntityTypes").start_array();
        for item_367 in var_365 {
            {
                array_366.value().string(item_367.as_str());
            }
        }
        array_366.finish();
    }
    if let Some(var_368) = &input.mask_mode {
        object.key("MaskMode").string(var_368.as_str());
    }
    if let Some(var_369) = &input.mask_character {
        object.key("MaskCharacter").string(var_369);
    }
    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::SerializationError> {
    if let Some(var_370) = &input.s3_uri {
        object.key("S3Uri").string(var_370);
    }
    if let Some(var_371) = &input.split {
        object.key("Split").string(var_371.as_str());
    }
    if let Some(var_372) = &input.attribute_names {
        let mut array_373 = object.key("AttributeNames").start_array();
        for item_374 in var_372 {
            {
                array_373.value().string(item_374);
            }
        }
        array_373.finish();
    }
    if let Some(var_375) = &input.annotation_data_s3_uri {
        object.key("AnnotationDataS3Uri").string(var_375);
    }
    if let Some(var_376) = &input.source_documents_s3_uri {
        object.key("SourceDocumentsS3Uri").string(var_376);
    }
    if let Some(var_377) = &input.document_type {
        object.key("DocumentType").string(var_377.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::SerializationError> {
    if let Some(var_378) = &input.r#type {
        object.key("Type").string(var_378);
    }
    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::SerializationError> {
    if let Some(var_379) = &input.s3_uri {
        object.key("S3Uri").string(var_379);
    }
    if let Some(var_380) = &input.test_s3_uri {
        object.key("TestS3Uri").string(var_380);
    }
    if let Some(var_381) = &input.input_format {
        object.key("InputFormat").string(var_381.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::SerializationError> {
    if let Some(var_382) = &input.s3_uri {
        object.key("S3Uri").string(var_382);
    }
    if let Some(var_383) = &input.test_s3_uri {
        object.key("TestS3Uri").string(var_383);
    }
    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::SerializationError> {
    if let Some(var_384) = &input.s3_uri {
        object.key("S3Uri").string(var_384);
    }
    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::SerializationError> {
    if let Some(var_385) = &input.document_read_action {
        object.key("DocumentReadAction").string(var_385.as_str());
    }
    if let Some(var_386) = &input.document_read_mode {
        object.key("DocumentReadMode").string(var_386.as_str());
    }
    if let Some(var_387) = &input.feature_types {
        let mut array_388 = object.key("FeatureTypes").start_array();
        for item_389 in var_387 {
            {
                array_388.value().string(item_389.as_str());
            }
        }
        array_388.finish();
    }
    Ok(())
}