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_1) = &input.dataset_name {
object.key("DatasetName").string(var_1.as_str());
}
if let Some(var_2) = &input.dataset_schema {
#[allow(unused_mut)]
let mut object_3 = object.key("DatasetSchema").start_object();
crate::json_ser::serialize_structure_crate_model_dataset_schema(&mut object_3, var_2)?;
object_3.finish();
}
if let Some(var_4) = &input.server_side_kms_key_id {
object.key("ServerSideKmsKeyId").string(var_4.as_str());
}
if let Some(var_5) = &input.client_token {
object.key("ClientToken").string(var_5.as_str());
}
if let Some(var_6) = &input.tags {
let mut array_7 = object.key("Tags").start_array();
for item_8 in var_6 {
{
#[allow(unused_mut)]
let mut object_9 = array_7.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_9, item_8)?;
object_9.finish();
}
}
array_7.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_inference_scheduler_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateInferenceSchedulerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_10) = &input.model_name {
object.key("ModelName").string(var_10.as_str());
}
if let Some(var_11) = &input.inference_scheduler_name {
object.key("InferenceSchedulerName").string(var_11.as_str());
}
if let Some(var_12) = &input.data_delay_offset_in_minutes {
object.key("DataDelayOffsetInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_12).into()),
);
}
if let Some(var_13) = &input.data_upload_frequency {
object.key("DataUploadFrequency").string(var_13.as_str());
}
if let Some(var_14) = &input.data_input_configuration {
#[allow(unused_mut)]
let mut object_15 = object.key("DataInputConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_inference_input_configuration(
&mut object_15,
var_14,
)?;
object_15.finish();
}
if let Some(var_16) = &input.data_output_configuration {
#[allow(unused_mut)]
let mut object_17 = object.key("DataOutputConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_inference_output_configuration(
&mut object_17,
var_16,
)?;
object_17.finish();
}
if let Some(var_18) = &input.role_arn {
object.key("RoleArn").string(var_18.as_str());
}
if let Some(var_19) = &input.server_side_kms_key_id {
object.key("ServerSideKmsKeyId").string(var_19.as_str());
}
if let Some(var_20) = &input.client_token {
object.key("ClientToken").string(var_20.as_str());
}
if let Some(var_21) = &input.tags {
let mut array_22 = object.key("Tags").start_array();
for item_23 in var_21 {
{
#[allow(unused_mut)]
let mut object_24 = array_22.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_24, item_23)?;
object_24.finish();
}
}
array_22.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_label_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLabelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_25) = &input.label_group_name {
object.key("LabelGroupName").string(var_25.as_str());
}
if let Some(var_26) = &input.start_time {
object
.key("StartTime")
.date_time(var_26, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_27) = &input.end_time {
object
.key("EndTime")
.date_time(var_27, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_28) = &input.rating {
object.key("Rating").string(var_28.as_str());
}
if let Some(var_29) = &input.fault_code {
object.key("FaultCode").string(var_29.as_str());
}
if let Some(var_30) = &input.notes {
object.key("Notes").string(var_30.as_str());
}
if let Some(var_31) = &input.equipment {
object.key("Equipment").string(var_31.as_str());
}
if let Some(var_32) = &input.client_token {
object.key("ClientToken").string(var_32.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_label_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLabelGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_33) = &input.label_group_name {
object.key("LabelGroupName").string(var_33.as_str());
}
if let Some(var_34) = &input.fault_codes {
let mut array_35 = object.key("FaultCodes").start_array();
for item_36 in var_34 {
{
array_35.value().string(item_36.as_str());
}
}
array_35.finish();
}
if let Some(var_37) = &input.client_token {
object.key("ClientToken").string(var_37.as_str());
}
if let Some(var_38) = &input.tags {
let mut array_39 = object.key("Tags").start_array();
for item_40 in var_38 {
{
#[allow(unused_mut)]
let mut object_41 = array_39.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_41, item_40)?;
object_41.finish();
}
}
array_39.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateModelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_42) = &input.model_name {
object.key("ModelName").string(var_42.as_str());
}
if let Some(var_43) = &input.dataset_name {
object.key("DatasetName").string(var_43.as_str());
}
if let Some(var_44) = &input.dataset_schema {
#[allow(unused_mut)]
let mut object_45 = object.key("DatasetSchema").start_object();
crate::json_ser::serialize_structure_crate_model_dataset_schema(&mut object_45, var_44)?;
object_45.finish();
}
if let Some(var_46) = &input.labels_input_configuration {
#[allow(unused_mut)]
let mut object_47 = object.key("LabelsInputConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_labels_input_configuration(
&mut object_47,
var_46,
)?;
object_47.finish();
}
if let Some(var_48) = &input.client_token {
object.key("ClientToken").string(var_48.as_str());
}
if let Some(var_49) = &input.training_data_start_time {
object
.key("TrainingDataStartTime")
.date_time(var_49, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_50) = &input.training_data_end_time {
object
.key("TrainingDataEndTime")
.date_time(var_50, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_51) = &input.evaluation_data_start_time {
object
.key("EvaluationDataStartTime")
.date_time(var_51, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_52) = &input.evaluation_data_end_time {
object
.key("EvaluationDataEndTime")
.date_time(var_52, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_53) = &input.role_arn {
object.key("RoleArn").string(var_53.as_str());
}
if let Some(var_54) = &input.data_pre_processing_configuration {
#[allow(unused_mut)]
let mut object_55 = object.key("DataPreProcessingConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_data_pre_processing_configuration(
&mut object_55,
var_54,
)?;
object_55.finish();
}
if let Some(var_56) = &input.server_side_kms_key_id {
object.key("ServerSideKmsKeyId").string(var_56.as_str());
}
if let Some(var_57) = &input.tags {
let mut array_58 = object.key("Tags").start_array();
for item_59 in var_57 {
{
#[allow(unused_mut)]
let mut object_60 = array_58.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_60, item_59)?;
object_60.finish();
}
}
array_58.finish();
}
if let Some(var_61) = &input.off_condition {
object.key("OffCondition").string(var_61.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_62) = &input.dataset_name {
object.key("DatasetName").string(var_62.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_inference_scheduler_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteInferenceSchedulerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_63) = &input.inference_scheduler_name {
object.key("InferenceSchedulerName").string(var_63.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_label_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteLabelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_64) = &input.label_group_name {
object.key("LabelGroupName").string(var_64.as_str());
}
if let Some(var_65) = &input.label_id {
object.key("LabelId").string(var_65.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_label_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteLabelGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_66) = &input.label_group_name {
object.key("LabelGroupName").string(var_66.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteModelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_67) = &input.model_name {
object.key("ModelName").string(var_67.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_data_ingestion_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDataIngestionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_68) = &input.job_id {
object.key("JobId").string(var_68.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_69) = &input.dataset_name {
object.key("DatasetName").string(var_69.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_inference_scheduler_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeInferenceSchedulerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.inference_scheduler_name {
object.key("InferenceSchedulerName").string(var_70.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_label_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeLabelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_71) = &input.label_group_name {
object.key("LabelGroupName").string(var_71.as_str());
}
if let Some(var_72) = &input.label_id {
object.key("LabelId").string(var_72.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_label_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeLabelGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_73) = &input.label_group_name {
object.key("LabelGroupName").string(var_73.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeModelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_74) = &input.model_name {
object.key("ModelName").string(var_74.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_data_ingestion_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDataIngestionJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_75) = &input.dataset_name {
object.key("DatasetName").string(var_75.as_str());
}
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.status {
object.key("Status").string(var_78.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_datasets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDatasetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_79) = &input.next_token {
object.key("NextToken").string(var_79.as_str());
}
if let Some(var_80) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_80).into()),
);
}
if let Some(var_81) = &input.dataset_name_begins_with {
object.key("DatasetNameBeginsWith").string(var_81.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_inference_events_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListInferenceEventsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_82) = &input.next_token {
object.key("NextToken").string(var_82.as_str());
}
if let Some(var_83) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_83).into()),
);
}
if let Some(var_84) = &input.inference_scheduler_name {
object.key("InferenceSchedulerName").string(var_84.as_str());
}
if let Some(var_85) = &input.interval_start_time {
object
.key("IntervalStartTime")
.date_time(var_85, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_86) = &input.interval_end_time {
object
.key("IntervalEndTime")
.date_time(var_86, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_input_list_inference_executions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListInferenceExecutionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_87) = &input.next_token {
object.key("NextToken").string(var_87.as_str());
}
if let Some(var_88) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_88).into()),
);
}
if let Some(var_89) = &input.inference_scheduler_name {
object.key("InferenceSchedulerName").string(var_89.as_str());
}
if let Some(var_90) = &input.data_start_time_after {
object
.key("DataStartTimeAfter")
.date_time(var_90, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_91) = &input.data_end_time_before {
object
.key("DataEndTimeBefore")
.date_time(var_91, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_92) = &input.status {
object.key("Status").string(var_92.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_inference_schedulers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListInferenceSchedulersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.next_token {
object.key("NextToken").string(var_93.as_str());
}
if let Some(var_94) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_94).into()),
);
}
if let Some(var_95) = &input.inference_scheduler_name_begins_with {
object
.key("InferenceSchedulerNameBeginsWith")
.string(var_95.as_str());
}
if let Some(var_96) = &input.model_name {
object.key("ModelName").string(var_96.as_str());
}
if let Some(var_97) = &input.status {
object.key("Status").string(var_97.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_label_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListLabelGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_98) = &input.label_group_name_begins_with {
object
.key("LabelGroupNameBeginsWith")
.string(var_98.as_str());
}
if let Some(var_99) = &input.next_token {
object.key("NextToken").string(var_99.as_str());
}
if let Some(var_100) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_100).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_labels_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListLabelsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_101) = &input.label_group_name {
object.key("LabelGroupName").string(var_101.as_str());
}
if let Some(var_102) = &input.interval_start_time {
object
.key("IntervalStartTime")
.date_time(var_102, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_103) = &input.interval_end_time {
object
.key("IntervalEndTime")
.date_time(var_103, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_104) = &input.fault_code {
object.key("FaultCode").string(var_104.as_str());
}
if let Some(var_105) = &input.equipment {
object.key("Equipment").string(var_105.as_str());
}
if let Some(var_106) = &input.next_token {
object.key("NextToken").string(var_106.as_str());
}
if let Some(var_107) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_107).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_models_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListModelsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_108) = &input.next_token {
object.key("NextToken").string(var_108.as_str());
}
if let Some(var_109) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_109).into()),
);
}
if let Some(var_110) = &input.status {
object.key("Status").string(var_110.as_str());
}
if let Some(var_111) = &input.model_name_begins_with {
object.key("ModelNameBeginsWith").string(var_111.as_str());
}
if let Some(var_112) = &input.dataset_name_begins_with {
object.key("DatasetNameBeginsWith").string(var_112.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_sensor_statistics_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSensorStatisticsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_113) = &input.dataset_name {
object.key("DatasetName").string(var_113.as_str());
}
if let Some(var_114) = &input.ingestion_job_id {
object.key("IngestionJobId").string(var_114.as_str());
}
if let Some(var_115) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_115).into()),
);
}
if let Some(var_116) = &input.next_token {
object.key("NextToken").string(var_116.as_str());
}
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_117) = &input.resource_arn {
object.key("ResourceArn").string(var_117.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_data_ingestion_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartDataIngestionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_118) = &input.dataset_name {
object.key("DatasetName").string(var_118.as_str());
}
if let Some(var_119) = &input.ingestion_input_configuration {
#[allow(unused_mut)]
let mut object_120 = object.key("IngestionInputConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_ingestion_input_configuration(
&mut object_120,
var_119,
)?;
object_120.finish();
}
if let Some(var_121) = &input.role_arn {
object.key("RoleArn").string(var_121.as_str());
}
if let Some(var_122) = &input.client_token {
object.key("ClientToken").string(var_122.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_inference_scheduler_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartInferenceSchedulerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_123) = &input.inference_scheduler_name {
object
.key("InferenceSchedulerName")
.string(var_123.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_inference_scheduler_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopInferenceSchedulerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_124) = &input.inference_scheduler_name {
object
.key("InferenceSchedulerName")
.string(var_124.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_125) = &input.resource_arn {
object.key("ResourceArn").string(var_125.as_str());
}
if let Some(var_126) = &input.tags {
let mut array_127 = object.key("Tags").start_array();
for item_128 in var_126 {
{
#[allow(unused_mut)]
let mut object_129 = array_127.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_129, item_128)?;
object_129.finish();
}
}
array_127.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_130) = &input.resource_arn {
object.key("ResourceArn").string(var_130.as_str());
}
if let Some(var_131) = &input.tag_keys {
let mut array_132 = object.key("TagKeys").start_array();
for item_133 in var_131 {
{
array_132.value().string(item_133.as_str());
}
}
array_132.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_inference_scheduler_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateInferenceSchedulerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_134) = &input.inference_scheduler_name {
object
.key("InferenceSchedulerName")
.string(var_134.as_str());
}
if let Some(var_135) = &input.data_delay_offset_in_minutes {
object.key("DataDelayOffsetInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_135).into()),
);
}
if let Some(var_136) = &input.data_upload_frequency {
object.key("DataUploadFrequency").string(var_136.as_str());
}
if let Some(var_137) = &input.data_input_configuration {
#[allow(unused_mut)]
let mut object_138 = object.key("DataInputConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_inference_input_configuration(
&mut object_138,
var_137,
)?;
object_138.finish();
}
if let Some(var_139) = &input.data_output_configuration {
#[allow(unused_mut)]
let mut object_140 = object.key("DataOutputConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_inference_output_configuration(
&mut object_140,
var_139,
)?;
object_140.finish();
}
if let Some(var_141) = &input.role_arn {
object.key("RoleArn").string(var_141.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_label_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateLabelGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_142) = &input.label_group_name {
object.key("LabelGroupName").string(var_142.as_str());
}
if let Some(var_143) = &input.fault_codes {
let mut array_144 = object.key("FaultCodes").start_array();
for item_145 in var_143 {
{
array_144.value().string(item_145.as_str());
}
}
array_144.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_dataset_schema(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatasetSchema,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.inline_data_schema {
object.key("InlineDataSchema").string(var_146.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_147) = &input.key {
object.key("Key").string(var_147.as_str());
}
if let Some(var_148) = &input.value {
object.key("Value").string(var_148.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_inference_input_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InferenceInputConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_149) = &input.s3_input_configuration {
#[allow(unused_mut)]
let mut object_150 = object.key("S3InputConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_inference_s3_input_configuration(
&mut object_150,
var_149,
)?;
object_150.finish();
}
if let Some(var_151) = &input.input_time_zone_offset {
object.key("InputTimeZoneOffset").string(var_151.as_str());
}
if let Some(var_152) = &input.inference_input_name_configuration {
#[allow(unused_mut)]
let mut object_153 = object.key("InferenceInputNameConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_inference_input_name_configuration(
&mut object_153,
var_152,
)?;
object_153.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_inference_output_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InferenceOutputConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_154) = &input.s3_output_configuration {
#[allow(unused_mut)]
let mut object_155 = object.key("S3OutputConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_inference_s3_output_configuration(
&mut object_155,
var_154,
)?;
object_155.finish();
}
if let Some(var_156) = &input.kms_key_id {
object.key("KmsKeyId").string(var_156.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_labels_input_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LabelsInputConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_157) = &input.s3_input_configuration {
#[allow(unused_mut)]
let mut object_158 = object.key("S3InputConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_labels_s3_input_configuration(
&mut object_158,
var_157,
)?;
object_158.finish();
}
if let Some(var_159) = &input.label_group_name {
object.key("LabelGroupName").string(var_159.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_pre_processing_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataPreProcessingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_160) = &input.target_sampling_rate {
object.key("TargetSamplingRate").string(var_160.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ingestion_input_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IngestionInputConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_161) = &input.s3_input_configuration {
#[allow(unused_mut)]
let mut object_162 = object.key("S3InputConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_ingestion_s3_input_configuration(
&mut object_162,
var_161,
)?;
object_162.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_inference_s3_input_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InferenceS3InputConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_163) = &input.bucket {
object.key("Bucket").string(var_163.as_str());
}
if let Some(var_164) = &input.prefix {
object.key("Prefix").string(var_164.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_inference_input_name_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InferenceInputNameConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_165) = &input.timestamp_format {
object.key("TimestampFormat").string(var_165.as_str());
}
if let Some(var_166) = &input.component_timestamp_delimiter {
object
.key("ComponentTimestampDelimiter")
.string(var_166.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_inference_s3_output_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InferenceS3OutputConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_167) = &input.bucket {
object.key("Bucket").string(var_167.as_str());
}
if let Some(var_168) = &input.prefix {
object.key("Prefix").string(var_168.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_labels_s3_input_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LabelsS3InputConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_169) = &input.bucket {
object.key("Bucket").string(var_169.as_str());
}
if let Some(var_170) = &input.prefix {
object.key("Prefix").string(var_170.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ingestion_s3_input_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IngestionS3InputConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_171) = &input.bucket {
object.key("Bucket").string(var_171.as_str());
}
if let Some(var_172) = &input.prefix {
object.key("Prefix").string(var_172.as_str());
}
if let Some(var_173) = &input.key_pattern {
object.key("KeyPattern").string(var_173.as_str());
}
Ok(())
}