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(())
}