pub fn serialize_structure_crate_input_compare_faces_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CompareFacesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.source_image {
#[allow(unused_mut)]
let mut object_2 = object.key("SourceImage").start_object();
crate::json_ser::serialize_structure_crate_model_image(&mut object_2, var_1)?;
object_2.finish();
}
if let Some(var_3) = &input.target_image {
#[allow(unused_mut)]
let mut object_4 = object.key("TargetImage").start_object();
crate::json_ser::serialize_structure_crate_model_image(&mut object_4, var_3)?;
object_4.finish();
}
if let Some(var_5) = &input.similarity_threshold {
object.key("SimilarityThreshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_5).into()),
);
}
if let Some(var_6) = &input.quality_filter {
object.key("QualityFilter").string(var_6.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_copy_project_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CopyProjectVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_7) = &input.source_project_arn {
object.key("SourceProjectArn").string(var_7.as_str());
}
if let Some(var_8) = &input.source_project_version_arn {
object.key("SourceProjectVersionArn").string(var_8.as_str());
}
if let Some(var_9) = &input.destination_project_arn {
object.key("DestinationProjectArn").string(var_9.as_str());
}
if let Some(var_10) = &input.version_name {
object.key("VersionName").string(var_10.as_str());
}
if let Some(var_11) = &input.output_config {
#[allow(unused_mut)]
let mut object_12 = object.key("OutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_output_config(&mut object_12, var_11)?;
object_12.finish();
}
if let Some(var_13) = &input.tags {
#[allow(unused_mut)]
let mut object_14 = object.key("Tags").start_object();
for (key_15, value_16) in var_13 {
{
object_14.key(key_15.as_str()).string(value_16.as_str());
}
}
object_14.finish();
}
if let Some(var_17) = &input.kms_key_id {
object.key("KmsKeyId").string(var_17.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_collection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateCollectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_18) = &input.collection_id {
object.key("CollectionId").string(var_18.as_str());
}
if let Some(var_19) = &input.tags {
#[allow(unused_mut)]
let mut object_20 = object.key("Tags").start_object();
for (key_21, value_22) in var_19 {
{
object_20.key(key_21.as_str()).string(value_22.as_str());
}
}
object_20.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_dataset_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDatasetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_23) = &input.dataset_source {
#[allow(unused_mut)]
let mut object_24 = object.key("DatasetSource").start_object();
crate::json_ser::serialize_structure_crate_model_dataset_source(&mut object_24, var_23)?;
object_24.finish();
}
if let Some(var_25) = &input.dataset_type {
object.key("DatasetType").string(var_25.as_str());
}
if let Some(var_26) = &input.project_arn {
object.key("ProjectArn").string(var_26.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_project_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateProjectInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_27) = &input.project_name {
object.key("ProjectName").string(var_27.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_project_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateProjectVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_28) = &input.project_arn {
object.key("ProjectArn").string(var_28.as_str());
}
if let Some(var_29) = &input.version_name {
object.key("VersionName").string(var_29.as_str());
}
if let Some(var_30) = &input.output_config {
#[allow(unused_mut)]
let mut object_31 = object.key("OutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_output_config(&mut object_31, var_30)?;
object_31.finish();
}
if let Some(var_32) = &input.training_data {
#[allow(unused_mut)]
let mut object_33 = object.key("TrainingData").start_object();
crate::json_ser::serialize_structure_crate_model_training_data(&mut object_33, var_32)?;
object_33.finish();
}
if let Some(var_34) = &input.testing_data {
#[allow(unused_mut)]
let mut object_35 = object.key("TestingData").start_object();
crate::json_ser::serialize_structure_crate_model_testing_data(&mut object_35, var_34)?;
object_35.finish();
}
if let Some(var_36) = &input.tags {
#[allow(unused_mut)]
let mut object_37 = object.key("Tags").start_object();
for (key_38, value_39) in var_36 {
{
object_37.key(key_38.as_str()).string(value_39.as_str());
}
}
object_37.finish();
}
if let Some(var_40) = &input.kms_key_id {
object.key("KmsKeyId").string(var_40.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_stream_processor_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateStreamProcessorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_41) = &input.input {
#[allow(unused_mut)]
let mut object_42 = object.key("Input").start_object();
crate::json_ser::serialize_structure_crate_model_stream_processor_input(
&mut object_42,
var_41,
)?;
object_42.finish();
}
if let Some(var_43) = &input.output {
#[allow(unused_mut)]
let mut object_44 = object.key("Output").start_object();
crate::json_ser::serialize_structure_crate_model_stream_processor_output(
&mut object_44,
var_43,
)?;
object_44.finish();
}
if let Some(var_45) = &input.name {
object.key("Name").string(var_45.as_str());
}
if let Some(var_46) = &input.settings {
#[allow(unused_mut)]
let mut object_47 = object.key("Settings").start_object();
crate::json_ser::serialize_structure_crate_model_stream_processor_settings(
&mut object_47,
var_46,
)?;
object_47.finish();
}
if let Some(var_48) = &input.role_arn {
object.key("RoleArn").string(var_48.as_str());
}
if let Some(var_49) = &input.tags {
#[allow(unused_mut)]
let mut object_50 = object.key("Tags").start_object();
for (key_51, value_52) in var_49 {
{
object_50.key(key_51.as_str()).string(value_52.as_str());
}
}
object_50.finish();
}
if let Some(var_53) = &input.notification_channel {
#[allow(unused_mut)]
let mut object_54 = object.key("NotificationChannel").start_object();
crate::json_ser::serialize_structure_crate_model_stream_processor_notification_channel(
&mut object_54,
var_53,
)?;
object_54.finish();
}
if let Some(var_55) = &input.kms_key_id {
object.key("KmsKeyId").string(var_55.as_str());
}
if let Some(var_56) = &input.regions_of_interest {
let mut array_57 = object.key("RegionsOfInterest").start_array();
for item_58 in var_56 {
{
#[allow(unused_mut)]
let mut object_59 = array_57.value().start_object();
crate::json_ser::serialize_structure_crate_model_region_of_interest(
&mut object_59,
item_58,
)?;
object_59.finish();
}
}
array_57.finish();
}
if let Some(var_60) = &input.data_sharing_preference {
#[allow(unused_mut)]
let mut object_61 = object.key("DataSharingPreference").start_object();
crate::json_ser::serialize_structure_crate_model_stream_processor_data_sharing_preference(
&mut object_61,
var_60,
)?;
object_61.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_collection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteCollectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_62) = &input.collection_id {
object.key("CollectionId").string(var_62.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_dataset_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteDatasetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_63) = &input.dataset_arn {
object.key("DatasetArn").string(var_63.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_faces_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteFacesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_64) = &input.collection_id {
object.key("CollectionId").string(var_64.as_str());
}
if let Some(var_65) = &input.face_ids {
let mut array_66 = object.key("FaceIds").start_array();
for item_67 in var_65 {
{
array_66.value().string(item_67.as_str());
}
}
array_66.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_project_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteProjectInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_68) = &input.project_arn {
object.key("ProjectArn").string(var_68.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_project_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteProjectPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_69) = &input.project_arn {
object.key("ProjectArn").string(var_69.as_str());
}
if let Some(var_70) = &input.policy_name {
object.key("PolicyName").string(var_70.as_str());
}
if let Some(var_71) = &input.policy_revision_id {
object.key("PolicyRevisionId").string(var_71.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_project_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteProjectVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_72) = &input.project_version_arn {
object.key("ProjectVersionArn").string(var_72.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_stream_processor_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteStreamProcessorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_73) = &input.name {
object.key("Name").string(var_73.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_collection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeCollectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_74) = &input.collection_id {
object.key("CollectionId").string(var_74.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_dataset_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDatasetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_75) = &input.dataset_arn {
object.key("DatasetArn").string(var_75.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_projects_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeProjectsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_76) = &input.next_token {
object.key("NextToken").string(var_76.as_str());
}
if let Some(var_77) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_77).into()),
);
}
if let Some(var_78) = &input.project_names {
let mut array_79 = object.key("ProjectNames").start_array();
for item_80 in var_78 {
{
array_79.value().string(item_80.as_str());
}
}
array_79.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_project_versions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeProjectVersionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.project_arn {
object.key("ProjectArn").string(var_81.as_str());
}
if let Some(var_82) = &input.version_names {
let mut array_83 = object.key("VersionNames").start_array();
for item_84 in var_82 {
{
array_83.value().string(item_84.as_str());
}
}
array_83.finish();
}
if let Some(var_85) = &input.next_token {
object.key("NextToken").string(var_85.as_str());
}
if let Some(var_86) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_86).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_stream_processor_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeStreamProcessorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_87) = &input.name {
object.key("Name").string(var_87.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_detect_custom_labels_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DetectCustomLabelsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_88) = &input.project_version_arn {
object.key("ProjectVersionArn").string(var_88.as_str());
}
if let Some(var_89) = &input.image {
#[allow(unused_mut)]
let mut object_90 = object.key("Image").start_object();
crate::json_ser::serialize_structure_crate_model_image(&mut object_90, var_89)?;
object_90.finish();
}
if let Some(var_91) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_91).into()),
);
}
if let Some(var_92) = &input.min_confidence {
object.key("MinConfidence").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_92).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_detect_faces_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DetectFacesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.image {
#[allow(unused_mut)]
let mut object_94 = object.key("Image").start_object();
crate::json_ser::serialize_structure_crate_model_image(&mut object_94, var_93)?;
object_94.finish();
}
if let Some(var_95) = &input.attributes {
let mut array_96 = object.key("Attributes").start_array();
for item_97 in var_95 {
{
array_96.value().string(item_97.as_str());
}
}
array_96.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_detect_labels_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DetectLabelsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_98) = &input.image {
#[allow(unused_mut)]
let mut object_99 = object.key("Image").start_object();
crate::json_ser::serialize_structure_crate_model_image(&mut object_99, var_98)?;
object_99.finish();
}
if let Some(var_100) = &input.max_labels {
object.key("MaxLabels").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_100).into()),
);
}
if let Some(var_101) = &input.min_confidence {
object.key("MinConfidence").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_101).into()),
);
}
if let Some(var_102) = &input.features {
let mut array_103 = object.key("Features").start_array();
for item_104 in var_102 {
{
array_103.value().string(item_104.as_str());
}
}
array_103.finish();
}
if let Some(var_105) = &input.settings {
#[allow(unused_mut)]
let mut object_106 = object.key("Settings").start_object();
crate::json_ser::serialize_structure_crate_model_detect_labels_settings(
&mut object_106,
var_105,
)?;
object_106.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_detect_moderation_labels_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DetectModerationLabelsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_107) = &input.image {
#[allow(unused_mut)]
let mut object_108 = object.key("Image").start_object();
crate::json_ser::serialize_structure_crate_model_image(&mut object_108, var_107)?;
object_108.finish();
}
if let Some(var_109) = &input.min_confidence {
object.key("MinConfidence").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_109).into()),
);
}
if let Some(var_110) = &input.human_loop_config {
#[allow(unused_mut)]
let mut object_111 = object.key("HumanLoopConfig").start_object();
crate::json_ser::serialize_structure_crate_model_human_loop_config(
&mut object_111,
var_110,
)?;
object_111.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_detect_protective_equipment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DetectProtectiveEquipmentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_112) = &input.image {
#[allow(unused_mut)]
let mut object_113 = object.key("Image").start_object();
crate::json_ser::serialize_structure_crate_model_image(&mut object_113, var_112)?;
object_113.finish();
}
if let Some(var_114) = &input.summarization_attributes {
#[allow(unused_mut)]
let mut object_115 = object.key("SummarizationAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_protective_equipment_summarization_attributes(&mut object_115, var_114)?;
object_115.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_detect_text_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DetectTextInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_116) = &input.image {
#[allow(unused_mut)]
let mut object_117 = object.key("Image").start_object();
crate::json_ser::serialize_structure_crate_model_image(&mut object_117, var_116)?;
object_117.finish();
}
if let Some(var_118) = &input.filters {
#[allow(unused_mut)]
let mut object_119 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_detect_text_filters(
&mut object_119,
var_118,
)?;
object_119.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_distribute_dataset_entries_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DistributeDatasetEntriesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_120) = &input.datasets {
let mut array_121 = object.key("Datasets").start_array();
for item_122 in var_120 {
{
#[allow(unused_mut)]
let mut object_123 = array_121.value().start_object();
crate::json_ser::serialize_structure_crate_model_distribute_dataset(
&mut object_123,
item_122,
)?;
object_123.finish();
}
}
array_121.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_celebrity_info_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetCelebrityInfoInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_124) = &input.id {
object.key("Id").string(var_124.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_celebrity_recognition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetCelebrityRecognitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_125) = &input.job_id {
object.key("JobId").string(var_125.as_str());
}
if let Some(var_126) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_126).into()),
);
}
if let Some(var_127) = &input.next_token {
object.key("NextToken").string(var_127.as_str());
}
if let Some(var_128) = &input.sort_by {
object.key("SortBy").string(var_128.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_content_moderation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetContentModerationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_129) = &input.job_id {
object.key("JobId").string(var_129.as_str());
}
if let Some(var_130) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_130).into()),
);
}
if let Some(var_131) = &input.next_token {
object.key("NextToken").string(var_131.as_str());
}
if let Some(var_132) = &input.sort_by {
object.key("SortBy").string(var_132.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_face_detection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetFaceDetectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_133) = &input.job_id {
object.key("JobId").string(var_133.as_str());
}
if let Some(var_134) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_134).into()),
);
}
if let Some(var_135) = &input.next_token {
object.key("NextToken").string(var_135.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_face_search_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetFaceSearchInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_136) = &input.job_id {
object.key("JobId").string(var_136.as_str());
}
if let Some(var_137) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_137).into()),
);
}
if let Some(var_138) = &input.next_token {
object.key("NextToken").string(var_138.as_str());
}
if let Some(var_139) = &input.sort_by {
object.key("SortBy").string(var_139.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_label_detection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetLabelDetectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_140) = &input.job_id {
object.key("JobId").string(var_140.as_str());
}
if let Some(var_141) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_141).into()),
);
}
if let Some(var_142) = &input.next_token {
object.key("NextToken").string(var_142.as_str());
}
if let Some(var_143) = &input.sort_by {
object.key("SortBy").string(var_143.as_str());
}
if let Some(var_144) = &input.aggregate_by {
object.key("AggregateBy").string(var_144.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_person_tracking_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetPersonTrackingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_145) = &input.job_id {
object.key("JobId").string(var_145.as_str());
}
if let Some(var_146) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_146).into()),
);
}
if let Some(var_147) = &input.next_token {
object.key("NextToken").string(var_147.as_str());
}
if let Some(var_148) = &input.sort_by {
object.key("SortBy").string(var_148.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_segment_detection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetSegmentDetectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_149) = &input.job_id {
object.key("JobId").string(var_149.as_str());
}
if let Some(var_150) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_150).into()),
);
}
if let Some(var_151) = &input.next_token {
object.key("NextToken").string(var_151.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_text_detection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetTextDetectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_152) = &input.job_id {
object.key("JobId").string(var_152.as_str());
}
if let Some(var_153) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_153).into()),
);
}
if let Some(var_154) = &input.next_token {
object.key("NextToken").string(var_154.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_index_faces_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::IndexFacesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_155) = &input.collection_id {
object.key("CollectionId").string(var_155.as_str());
}
if let Some(var_156) = &input.image {
#[allow(unused_mut)]
let mut object_157 = object.key("Image").start_object();
crate::json_ser::serialize_structure_crate_model_image(&mut object_157, var_156)?;
object_157.finish();
}
if let Some(var_158) = &input.external_image_id {
object.key("ExternalImageId").string(var_158.as_str());
}
if let Some(var_159) = &input.detection_attributes {
let mut array_160 = object.key("DetectionAttributes").start_array();
for item_161 in var_159 {
{
array_160.value().string(item_161.as_str());
}
}
array_160.finish();
}
if let Some(var_162) = &input.max_faces {
object.key("MaxFaces").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_162).into()),
);
}
if let Some(var_163) = &input.quality_filter {
object.key("QualityFilter").string(var_163.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_collections_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListCollectionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_164) = &input.next_token {
object.key("NextToken").string(var_164.as_str());
}
if let Some(var_165) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_165).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_dataset_entries_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDatasetEntriesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_166) = &input.dataset_arn {
object.key("DatasetArn").string(var_166.as_str());
}
if let Some(var_167) = &input.contains_labels {
let mut array_168 = object.key("ContainsLabels").start_array();
for item_169 in var_167 {
{
array_168.value().string(item_169.as_str());
}
}
array_168.finish();
}
if let Some(var_170) = &input.labeled {
object.key("Labeled").boolean(*var_170);
}
if let Some(var_171) = &input.source_ref_contains {
object.key("SourceRefContains").string(var_171.as_str());
}
if let Some(var_172) = &input.has_errors {
object.key("HasErrors").boolean(*var_172);
}
if let Some(var_173) = &input.next_token {
object.key("NextToken").string(var_173.as_str());
}
if let Some(var_174) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_174).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_dataset_labels_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDatasetLabelsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_175) = &input.dataset_arn {
object.key("DatasetArn").string(var_175.as_str());
}
if let Some(var_176) = &input.next_token {
object.key("NextToken").string(var_176.as_str());
}
if let Some(var_177) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_177).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_faces_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListFacesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_178) = &input.collection_id {
object.key("CollectionId").string(var_178.as_str());
}
if let Some(var_179) = &input.next_token {
object.key("NextToken").string(var_179.as_str());
}
if let Some(var_180) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_180).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_project_policies_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListProjectPoliciesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_181) = &input.project_arn {
object.key("ProjectArn").string(var_181.as_str());
}
if let Some(var_182) = &input.next_token {
object.key("NextToken").string(var_182.as_str());
}
if let Some(var_183) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_183).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_stream_processors_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListStreamProcessorsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_184) = &input.next_token {
object.key("NextToken").string(var_184.as_str());
}
if let Some(var_185) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_185).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tags_for_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTagsForResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_186) = &input.resource_arn {
object.key("ResourceArn").string(var_186.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_project_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutProjectPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_187) = &input.project_arn {
object.key("ProjectArn").string(var_187.as_str());
}
if let Some(var_188) = &input.policy_name {
object.key("PolicyName").string(var_188.as_str());
}
if let Some(var_189) = &input.policy_revision_id {
object.key("PolicyRevisionId").string(var_189.as_str());
}
if let Some(var_190) = &input.policy_document {
object.key("PolicyDocument").string(var_190.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_recognize_celebrities_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RecognizeCelebritiesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_191) = &input.image {
#[allow(unused_mut)]
let mut object_192 = object.key("Image").start_object();
crate::json_ser::serialize_structure_crate_model_image(&mut object_192, var_191)?;
object_192.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_search_faces_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchFacesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_193) = &input.collection_id {
object.key("CollectionId").string(var_193.as_str());
}
if let Some(var_194) = &input.face_id {
object.key("FaceId").string(var_194.as_str());
}
if let Some(var_195) = &input.max_faces {
object.key("MaxFaces").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_195).into()),
);
}
if let Some(var_196) = &input.face_match_threshold {
object.key("FaceMatchThreshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_196).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_search_faces_by_image_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchFacesByImageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_197) = &input.collection_id {
object.key("CollectionId").string(var_197.as_str());
}
if let Some(var_198) = &input.image {
#[allow(unused_mut)]
let mut object_199 = object.key("Image").start_object();
crate::json_ser::serialize_structure_crate_model_image(&mut object_199, var_198)?;
object_199.finish();
}
if let Some(var_200) = &input.max_faces {
object.key("MaxFaces").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_200).into()),
);
}
if let Some(var_201) = &input.face_match_threshold {
object.key("FaceMatchThreshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_201).into()),
);
}
if let Some(var_202) = &input.quality_filter {
object.key("QualityFilter").string(var_202.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_celebrity_recognition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartCelebrityRecognitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_203) = &input.video {
#[allow(unused_mut)]
let mut object_204 = object.key("Video").start_object();
crate::json_ser::serialize_structure_crate_model_video(&mut object_204, var_203)?;
object_204.finish();
}
if let Some(var_205) = &input.client_request_token {
object.key("ClientRequestToken").string(var_205.as_str());
}
if let Some(var_206) = &input.notification_channel {
#[allow(unused_mut)]
let mut object_207 = object.key("NotificationChannel").start_object();
crate::json_ser::serialize_structure_crate_model_notification_channel(
&mut object_207,
var_206,
)?;
object_207.finish();
}
if let Some(var_208) = &input.job_tag {
object.key("JobTag").string(var_208.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_content_moderation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartContentModerationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_209) = &input.video {
#[allow(unused_mut)]
let mut object_210 = object.key("Video").start_object();
crate::json_ser::serialize_structure_crate_model_video(&mut object_210, var_209)?;
object_210.finish();
}
if let Some(var_211) = &input.min_confidence {
object.key("MinConfidence").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_211).into()),
);
}
if let Some(var_212) = &input.client_request_token {
object.key("ClientRequestToken").string(var_212.as_str());
}
if let Some(var_213) = &input.notification_channel {
#[allow(unused_mut)]
let mut object_214 = object.key("NotificationChannel").start_object();
crate::json_ser::serialize_structure_crate_model_notification_channel(
&mut object_214,
var_213,
)?;
object_214.finish();
}
if let Some(var_215) = &input.job_tag {
object.key("JobTag").string(var_215.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_face_detection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartFaceDetectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_216) = &input.video {
#[allow(unused_mut)]
let mut object_217 = object.key("Video").start_object();
crate::json_ser::serialize_structure_crate_model_video(&mut object_217, var_216)?;
object_217.finish();
}
if let Some(var_218) = &input.client_request_token {
object.key("ClientRequestToken").string(var_218.as_str());
}
if let Some(var_219) = &input.notification_channel {
#[allow(unused_mut)]
let mut object_220 = object.key("NotificationChannel").start_object();
crate::json_ser::serialize_structure_crate_model_notification_channel(
&mut object_220,
var_219,
)?;
object_220.finish();
}
if let Some(var_221) = &input.face_attributes {
object.key("FaceAttributes").string(var_221.as_str());
}
if let Some(var_222) = &input.job_tag {
object.key("JobTag").string(var_222.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_face_search_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartFaceSearchInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_223) = &input.video {
#[allow(unused_mut)]
let mut object_224 = object.key("Video").start_object();
crate::json_ser::serialize_structure_crate_model_video(&mut object_224, var_223)?;
object_224.finish();
}
if let Some(var_225) = &input.client_request_token {
object.key("ClientRequestToken").string(var_225.as_str());
}
if let Some(var_226) = &input.face_match_threshold {
object.key("FaceMatchThreshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_226).into()),
);
}
if let Some(var_227) = &input.collection_id {
object.key("CollectionId").string(var_227.as_str());
}
if let Some(var_228) = &input.notification_channel {
#[allow(unused_mut)]
let mut object_229 = object.key("NotificationChannel").start_object();
crate::json_ser::serialize_structure_crate_model_notification_channel(
&mut object_229,
var_228,
)?;
object_229.finish();
}
if let Some(var_230) = &input.job_tag {
object.key("JobTag").string(var_230.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_label_detection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartLabelDetectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_231) = &input.video {
#[allow(unused_mut)]
let mut object_232 = object.key("Video").start_object();
crate::json_ser::serialize_structure_crate_model_video(&mut object_232, var_231)?;
object_232.finish();
}
if let Some(var_233) = &input.client_request_token {
object.key("ClientRequestToken").string(var_233.as_str());
}
if let Some(var_234) = &input.min_confidence {
object.key("MinConfidence").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_234).into()),
);
}
if let Some(var_235) = &input.notification_channel {
#[allow(unused_mut)]
let mut object_236 = object.key("NotificationChannel").start_object();
crate::json_ser::serialize_structure_crate_model_notification_channel(
&mut object_236,
var_235,
)?;
object_236.finish();
}
if let Some(var_237) = &input.job_tag {
object.key("JobTag").string(var_237.as_str());
}
if let Some(var_238) = &input.features {
let mut array_239 = object.key("Features").start_array();
for item_240 in var_238 {
{
array_239.value().string(item_240.as_str());
}
}
array_239.finish();
}
if let Some(var_241) = &input.settings {
#[allow(unused_mut)]
let mut object_242 = object.key("Settings").start_object();
crate::json_ser::serialize_structure_crate_model_label_detection_settings(
&mut object_242,
var_241,
)?;
object_242.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_person_tracking_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartPersonTrackingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_243) = &input.video {
#[allow(unused_mut)]
let mut object_244 = object.key("Video").start_object();
crate::json_ser::serialize_structure_crate_model_video(&mut object_244, var_243)?;
object_244.finish();
}
if let Some(var_245) = &input.client_request_token {
object.key("ClientRequestToken").string(var_245.as_str());
}
if let Some(var_246) = &input.notification_channel {
#[allow(unused_mut)]
let mut object_247 = object.key("NotificationChannel").start_object();
crate::json_ser::serialize_structure_crate_model_notification_channel(
&mut object_247,
var_246,
)?;
object_247.finish();
}
if let Some(var_248) = &input.job_tag {
object.key("JobTag").string(var_248.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_project_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartProjectVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_249) = &input.project_version_arn {
object.key("ProjectVersionArn").string(var_249.as_str());
}
if let Some(var_250) = &input.min_inference_units {
object.key("MinInferenceUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_250).into()),
);
}
if let Some(var_251) = &input.max_inference_units {
object.key("MaxInferenceUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_251).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_start_segment_detection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartSegmentDetectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_252) = &input.video {
#[allow(unused_mut)]
let mut object_253 = object.key("Video").start_object();
crate::json_ser::serialize_structure_crate_model_video(&mut object_253, var_252)?;
object_253.finish();
}
if let Some(var_254) = &input.client_request_token {
object.key("ClientRequestToken").string(var_254.as_str());
}
if let Some(var_255) = &input.notification_channel {
#[allow(unused_mut)]
let mut object_256 = object.key("NotificationChannel").start_object();
crate::json_ser::serialize_structure_crate_model_notification_channel(
&mut object_256,
var_255,
)?;
object_256.finish();
}
if let Some(var_257) = &input.job_tag {
object.key("JobTag").string(var_257.as_str());
}
if let Some(var_258) = &input.filters {
#[allow(unused_mut)]
let mut object_259 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_start_segment_detection_filters(
&mut object_259,
var_258,
)?;
object_259.finish();
}
if let Some(var_260) = &input.segment_types {
let mut array_261 = object.key("SegmentTypes").start_array();
for item_262 in var_260 {
{
array_261.value().string(item_262.as_str());
}
}
array_261.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_stream_processor_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartStreamProcessorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_263) = &input.name {
object.key("Name").string(var_263.as_str());
}
if let Some(var_264) = &input.start_selector {
#[allow(unused_mut)]
let mut object_265 = object.key("StartSelector").start_object();
crate::json_ser::serialize_structure_crate_model_stream_processing_start_selector(
&mut object_265,
var_264,
)?;
object_265.finish();
}
if let Some(var_266) = &input.stop_selector {
#[allow(unused_mut)]
let mut object_267 = object.key("StopSelector").start_object();
crate::json_ser::serialize_structure_crate_model_stream_processing_stop_selector(
&mut object_267,
var_266,
)?;
object_267.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_text_detection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartTextDetectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_268) = &input.video {
#[allow(unused_mut)]
let mut object_269 = object.key("Video").start_object();
crate::json_ser::serialize_structure_crate_model_video(&mut object_269, var_268)?;
object_269.finish();
}
if let Some(var_270) = &input.client_request_token {
object.key("ClientRequestToken").string(var_270.as_str());
}
if let Some(var_271) = &input.notification_channel {
#[allow(unused_mut)]
let mut object_272 = object.key("NotificationChannel").start_object();
crate::json_ser::serialize_structure_crate_model_notification_channel(
&mut object_272,
var_271,
)?;
object_272.finish();
}
if let Some(var_273) = &input.job_tag {
object.key("JobTag").string(var_273.as_str());
}
if let Some(var_274) = &input.filters {
#[allow(unused_mut)]
let mut object_275 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_start_text_detection_filters(
&mut object_275,
var_274,
)?;
object_275.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_project_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopProjectVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_276) = &input.project_version_arn {
object.key("ProjectVersionArn").string(var_276.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_stream_processor_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopStreamProcessorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_277) = &input.name {
object.key("Name").string(var_277.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_278) = &input.resource_arn {
object.key("ResourceArn").string(var_278.as_str());
}
if let Some(var_279) = &input.tags {
#[allow(unused_mut)]
let mut object_280 = object.key("Tags").start_object();
for (key_281, value_282) in var_279 {
{
object_280.key(key_281.as_str()).string(value_282.as_str());
}
}
object_280.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_untag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UntagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_283) = &input.resource_arn {
object.key("ResourceArn").string(var_283.as_str());
}
if let Some(var_284) = &input.tag_keys {
let mut array_285 = object.key("TagKeys").start_array();
for item_286 in var_284 {
{
array_285.value().string(item_286.as_str());
}
}
array_285.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_dataset_entries_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDatasetEntriesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_287) = &input.dataset_arn {
object.key("DatasetArn").string(var_287.as_str());
}
if let Some(var_288) = &input.changes {
#[allow(unused_mut)]
let mut object_289 = object.key("Changes").start_object();
crate::json_ser::serialize_structure_crate_model_dataset_changes(&mut object_289, var_288)?;
object_289.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_stream_processor_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateStreamProcessorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_290) = &input.name {
object.key("Name").string(var_290.as_str());
}
if let Some(var_291) = &input.settings_for_update {
#[allow(unused_mut)]
let mut object_292 = object.key("SettingsForUpdate").start_object();
crate::json_ser::serialize_structure_crate_model_stream_processor_settings_for_update(
&mut object_292,
var_291,
)?;
object_292.finish();
}
if let Some(var_293) = &input.regions_of_interest_for_update {
let mut array_294 = object.key("RegionsOfInterestForUpdate").start_array();
for item_295 in var_293 {
{
#[allow(unused_mut)]
let mut object_296 = array_294.value().start_object();
crate::json_ser::serialize_structure_crate_model_region_of_interest(
&mut object_296,
item_295,
)?;
object_296.finish();
}
}
array_294.finish();
}
if let Some(var_297) = &input.data_sharing_preference_for_update {
#[allow(unused_mut)]
let mut object_298 = object.key("DataSharingPreferenceForUpdate").start_object();
crate::json_ser::serialize_structure_crate_model_stream_processor_data_sharing_preference(
&mut object_298,
var_297,
)?;
object_298.finish();
}
if let Some(var_299) = &input.parameters_to_delete {
let mut array_300 = object.key("ParametersToDelete").start_array();
for item_301 in var_299 {
{
array_300.value().string(item_301.as_str());
}
}
array_300.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_image(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Image,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_302) = &input.bytes {
object
.key("Bytes")
.string_unchecked(&aws_smithy_types::base64::encode(var_302));
}
if let Some(var_303) = &input.s3_object {
#[allow(unused_mut)]
let mut object_304 = object.key("S3Object").start_object();
crate::json_ser::serialize_structure_crate_model_s3_object(&mut object_304, var_303)?;
object_304.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_output_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OutputConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_305) = &input.s3_bucket {
object.key("S3Bucket").string(var_305.as_str());
}
if let Some(var_306) = &input.s3_key_prefix {
object.key("S3KeyPrefix").string(var_306.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_dataset_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatasetSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_307) = &input.ground_truth_manifest {
#[allow(unused_mut)]
let mut object_308 = object.key("GroundTruthManifest").start_object();
crate::json_ser::serialize_structure_crate_model_ground_truth_manifest(
&mut object_308,
var_307,
)?;
object_308.finish();
}
if let Some(var_309) = &input.dataset_arn {
object.key("DatasetArn").string(var_309.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_training_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TrainingData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_310) = &input.assets {
let mut array_311 = object.key("Assets").start_array();
for item_312 in var_310 {
{
#[allow(unused_mut)]
let mut object_313 = array_311.value().start_object();
crate::json_ser::serialize_structure_crate_model_asset(&mut object_313, item_312)?;
object_313.finish();
}
}
array_311.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_testing_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TestingData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_314) = &input.assets {
let mut array_315 = object.key("Assets").start_array();
for item_316 in var_314 {
{
#[allow(unused_mut)]
let mut object_317 = array_315.value().start_object();
crate::json_ser::serialize_structure_crate_model_asset(&mut object_317, item_316)?;
object_317.finish();
}
}
array_315.finish();
}
if input.auto_create {
object.key("AutoCreate").boolean(input.auto_create);
}
Ok(())
}
pub fn serialize_structure_crate_model_stream_processor_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StreamProcessorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_318) = &input.kinesis_video_stream {
#[allow(unused_mut)]
let mut object_319 = object.key("KinesisVideoStream").start_object();
crate::json_ser::serialize_structure_crate_model_kinesis_video_stream(
&mut object_319,
var_318,
)?;
object_319.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_stream_processor_output(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StreamProcessorOutput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_320) = &input.kinesis_data_stream {
#[allow(unused_mut)]
let mut object_321 = object.key("KinesisDataStream").start_object();
crate::json_ser::serialize_structure_crate_model_kinesis_data_stream(
&mut object_321,
var_320,
)?;
object_321.finish();
}
if let Some(var_322) = &input.s3_destination {
#[allow(unused_mut)]
let mut object_323 = object.key("S3Destination").start_object();
crate::json_ser::serialize_structure_crate_model_s3_destination(&mut object_323, var_322)?;
object_323.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_stream_processor_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StreamProcessorSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_324) = &input.face_search {
#[allow(unused_mut)]
let mut object_325 = object.key("FaceSearch").start_object();
crate::json_ser::serialize_structure_crate_model_face_search_settings(
&mut object_325,
var_324,
)?;
object_325.finish();
}
if let Some(var_326) = &input.connected_home {
#[allow(unused_mut)]
let mut object_327 = object.key("ConnectedHome").start_object();
crate::json_ser::serialize_structure_crate_model_connected_home_settings(
&mut object_327,
var_326,
)?;
object_327.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_stream_processor_notification_channel(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StreamProcessorNotificationChannel,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_328) = &input.sns_topic_arn {
object.key("SNSTopicArn").string(var_328.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_region_of_interest(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RegionOfInterest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_329) = &input.bounding_box {
#[allow(unused_mut)]
let mut object_330 = object.key("BoundingBox").start_object();
crate::json_ser::serialize_structure_crate_model_bounding_box(&mut object_330, var_329)?;
object_330.finish();
}
if let Some(var_331) = &input.polygon {
let mut array_332 = object.key("Polygon").start_array();
for item_333 in var_331 {
{
#[allow(unused_mut)]
let mut object_334 = array_332.value().start_object();
crate::json_ser::serialize_structure_crate_model_point(&mut object_334, item_333)?;
object_334.finish();
}
}
array_332.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_stream_processor_data_sharing_preference(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StreamProcessorDataSharingPreference,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("OptIn").boolean(input.opt_in);
}
Ok(())
}
pub fn serialize_structure_crate_model_detect_labels_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DetectLabelsSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_335) = &input.general_labels {
#[allow(unused_mut)]
let mut object_336 = object.key("GeneralLabels").start_object();
crate::json_ser::serialize_structure_crate_model_general_labels_settings(
&mut object_336,
var_335,
)?;
object_336.finish();
}
if let Some(var_337) = &input.image_properties {
#[allow(unused_mut)]
let mut object_338 = object.key("ImageProperties").start_object();
crate::json_ser::serialize_structure_crate_model_detect_labels_image_properties_settings(
&mut object_338,
var_337,
)?;
object_338.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_human_loop_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HumanLoopConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_339) = &input.human_loop_name {
object.key("HumanLoopName").string(var_339.as_str());
}
if let Some(var_340) = &input.flow_definition_arn {
object.key("FlowDefinitionArn").string(var_340.as_str());
}
if let Some(var_341) = &input.data_attributes {
#[allow(unused_mut)]
let mut object_342 = object.key("DataAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_human_loop_data_attributes(
&mut object_342,
var_341,
)?;
object_342.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_protective_equipment_summarization_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProtectiveEquipmentSummarizationAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_343) = &input.min_confidence {
object.key("MinConfidence").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_343).into()),
);
}
if let Some(var_344) = &input.required_equipment_types {
let mut array_345 = object.key("RequiredEquipmentTypes").start_array();
for item_346 in var_344 {
{
array_345.value().string(item_346.as_str());
}
}
array_345.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_detect_text_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DetectTextFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_347) = &input.word_filter {
#[allow(unused_mut)]
let mut object_348 = object.key("WordFilter").start_object();
crate::json_ser::serialize_structure_crate_model_detection_filter(
&mut object_348,
var_347,
)?;
object_348.finish();
}
if let Some(var_349) = &input.regions_of_interest {
let mut array_350 = object.key("RegionsOfInterest").start_array();
for item_351 in var_349 {
{
#[allow(unused_mut)]
let mut object_352 = array_350.value().start_object();
crate::json_ser::serialize_structure_crate_model_region_of_interest(
&mut object_352,
item_351,
)?;
object_352.finish();
}
}
array_350.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_distribute_dataset(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DistributeDataset,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_353) = &input.arn {
object.key("Arn").string(var_353.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_video(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Video,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_354) = &input.s3_object {
#[allow(unused_mut)]
let mut object_355 = object.key("S3Object").start_object();
crate::json_ser::serialize_structure_crate_model_s3_object(&mut object_355, var_354)?;
object_355.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_notification_channel(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NotificationChannel,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_356) = &input.sns_topic_arn {
object.key("SNSTopicArn").string(var_356.as_str());
}
if let Some(var_357) = &input.role_arn {
object.key("RoleArn").string(var_357.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_label_detection_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LabelDetectionSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_358) = &input.general_labels {
#[allow(unused_mut)]
let mut object_359 = object.key("GeneralLabels").start_object();
crate::json_ser::serialize_structure_crate_model_general_labels_settings(
&mut object_359,
var_358,
)?;
object_359.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_start_segment_detection_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StartSegmentDetectionFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_360) = &input.technical_cue_filter {
#[allow(unused_mut)]
let mut object_361 = object.key("TechnicalCueFilter").start_object();
crate::json_ser::serialize_structure_crate_model_start_technical_cue_detection_filter(
&mut object_361,
var_360,
)?;
object_361.finish();
}
if let Some(var_362) = &input.shot_filter {
#[allow(unused_mut)]
let mut object_363 = object.key("ShotFilter").start_object();
crate::json_ser::serialize_structure_crate_model_start_shot_detection_filter(
&mut object_363,
var_362,
)?;
object_363.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_stream_processing_start_selector(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StreamProcessingStartSelector,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_364) = &input.kvs_stream_start_selector {
#[allow(unused_mut)]
let mut object_365 = object.key("KVSStreamStartSelector").start_object();
crate::json_ser::serialize_structure_crate_model_kinesis_video_stream_start_selector(
&mut object_365,
var_364,
)?;
object_365.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_stream_processing_stop_selector(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StreamProcessingStopSelector,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_366) = &input.max_duration_in_seconds {
object.key("MaxDurationInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_366).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_start_text_detection_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StartTextDetectionFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_367) = &input.word_filter {
#[allow(unused_mut)]
let mut object_368 = object.key("WordFilter").start_object();
crate::json_ser::serialize_structure_crate_model_detection_filter(
&mut object_368,
var_367,
)?;
object_368.finish();
}
if let Some(var_369) = &input.regions_of_interest {
let mut array_370 = object.key("RegionsOfInterest").start_array();
for item_371 in var_369 {
{
#[allow(unused_mut)]
let mut object_372 = array_370.value().start_object();
crate::json_ser::serialize_structure_crate_model_region_of_interest(
&mut object_372,
item_371,
)?;
object_372.finish();
}
}
array_370.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_dataset_changes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatasetChanges,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_373) = &input.ground_truth {
object
.key("GroundTruth")
.string_unchecked(&aws_smithy_types::base64::encode(var_373));
}
Ok(())
}
pub fn serialize_structure_crate_model_stream_processor_settings_for_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StreamProcessorSettingsForUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_374) = &input.connected_home_for_update {
#[allow(unused_mut)]
let mut object_375 = object.key("ConnectedHomeForUpdate").start_object();
crate::json_ser::serialize_structure_crate_model_connected_home_settings_for_update(
&mut object_375,
var_374,
)?;
object_375.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_object(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3Object,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_376) = &input.bucket {
object.key("Bucket").string(var_376.as_str());
}
if let Some(var_377) = &input.name {
object.key("Name").string(var_377.as_str());
}
if let Some(var_378) = &input.version {
object.key("Version").string(var_378.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ground_truth_manifest(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GroundTruthManifest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_379) = &input.s3_object {
#[allow(unused_mut)]
let mut object_380 = object.key("S3Object").start_object();
crate::json_ser::serialize_structure_crate_model_s3_object(&mut object_380, var_379)?;
object_380.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_asset(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Asset,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_381) = &input.ground_truth_manifest {
#[allow(unused_mut)]
let mut object_382 = object.key("GroundTruthManifest").start_object();
crate::json_ser::serialize_structure_crate_model_ground_truth_manifest(
&mut object_382,
var_381,
)?;
object_382.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_kinesis_video_stream(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KinesisVideoStream,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_383) = &input.arn {
object.key("Arn").string(var_383.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_kinesis_data_stream(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KinesisDataStream,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_384) = &input.arn {
object.key("Arn").string(var_384.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_destination(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3Destination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_385) = &input.bucket {
object.key("Bucket").string(var_385.as_str());
}
if let Some(var_386) = &input.key_prefix {
object.key("KeyPrefix").string(var_386.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_face_search_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FaceSearchSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_387) = &input.collection_id {
object.key("CollectionId").string(var_387.as_str());
}
if let Some(var_388) = &input.face_match_threshold {
object.key("FaceMatchThreshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_388).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_connected_home_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConnectedHomeSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_389) = &input.labels {
let mut array_390 = object.key("Labels").start_array();
for item_391 in var_389 {
{
array_390.value().string(item_391.as_str());
}
}
array_390.finish();
}
if let Some(var_392) = &input.min_confidence {
object.key("MinConfidence").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_392).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_bounding_box(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BoundingBox,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_393) = &input.width {
object.key("Width").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_393).into()),
);
}
if let Some(var_394) = &input.height {
object.key("Height").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_394).into()),
);
}
if let Some(var_395) = &input.left {
object.key("Left").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_395).into()),
);
}
if let Some(var_396) = &input.top {
object.key("Top").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_396).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_point(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Point,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_397) = &input.x {
object.key("X").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_397).into()),
);
}
if let Some(var_398) = &input.y {
object.key("Y").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_398).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_general_labels_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GeneralLabelsSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_399) = &input.label_inclusion_filters {
let mut array_400 = object.key("LabelInclusionFilters").start_array();
for item_401 in var_399 {
{
array_400.value().string(item_401.as_str());
}
}
array_400.finish();
}
if let Some(var_402) = &input.label_exclusion_filters {
let mut array_403 = object.key("LabelExclusionFilters").start_array();
for item_404 in var_402 {
{
array_403.value().string(item_404.as_str());
}
}
array_403.finish();
}
if let Some(var_405) = &input.label_category_inclusion_filters {
let mut array_406 = object.key("LabelCategoryInclusionFilters").start_array();
for item_407 in var_405 {
{
array_406.value().string(item_407.as_str());
}
}
array_406.finish();
}
if let Some(var_408) = &input.label_category_exclusion_filters {
let mut array_409 = object.key("LabelCategoryExclusionFilters").start_array();
for item_410 in var_408 {
{
array_409.value().string(item_410.as_str());
}
}
array_409.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_detect_labels_image_properties_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DetectLabelsImagePropertiesSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.max_dominant_colors != 0 {
object.key("MaxDominantColors").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_dominant_colors).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_human_loop_data_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HumanLoopDataAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_411) = &input.content_classifiers {
let mut array_412 = object.key("ContentClassifiers").start_array();
for item_413 in var_411 {
{
array_412.value().string(item_413.as_str());
}
}
array_412.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_detection_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DetectionFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_414) = &input.min_confidence {
object.key("MinConfidence").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_414).into()),
);
}
if let Some(var_415) = &input.min_bounding_box_height {
object.key("MinBoundingBoxHeight").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_415).into()),
);
}
if let Some(var_416) = &input.min_bounding_box_width {
object.key("MinBoundingBoxWidth").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_416).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_start_technical_cue_detection_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StartTechnicalCueDetectionFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_417) = &input.min_segment_confidence {
object.key("MinSegmentConfidence").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_417).into()),
);
}
if let Some(var_418) = &input.black_frame {
#[allow(unused_mut)]
let mut object_419 = object.key("BlackFrame").start_object();
crate::json_ser::serialize_structure_crate_model_black_frame(&mut object_419, var_418)?;
object_419.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_start_shot_detection_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StartShotDetectionFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_420) = &input.min_segment_confidence {
object.key("MinSegmentConfidence").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_420).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_kinesis_video_stream_start_selector(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KinesisVideoStreamStartSelector,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_421) = &input.producer_timestamp {
object.key("ProducerTimestamp").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_421).into()),
);
}
if let Some(var_422) = &input.fragment_number {
object.key("FragmentNumber").string(var_422.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_connected_home_settings_for_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConnectedHomeSettingsForUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_423) = &input.labels {
let mut array_424 = object.key("Labels").start_array();
for item_425 in var_423 {
{
array_424.value().string(item_425.as_str());
}
}
array_424.finish();
}
if let Some(var_426) = &input.min_confidence {
object.key("MinConfidence").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_426).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_black_frame(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BlackFrame,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_427) = &input.max_pixel_threshold {
object.key("MaxPixelThreshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_427).into()),
);
}
if let Some(var_428) = &input.min_coverage_percentage {
object.key("MinCoveragePercentage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_428).into()),
);
}
Ok(())
}