pub fn serialize_structure_crate_input_batch_create_variable_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchCreateVariableInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.variable_entries {
let mut array_2 = object.key("variableEntries").start_array();
for item_3 in var_1 {
{
#[allow(unused_mut)]
let mut object_4 = array_2.value().start_object();
crate::json_ser::serialize_structure_crate_model_variable_entry(
&mut object_4,
item_3,
)?;
object_4.finish();
}
}
array_2.finish();
}
if let Some(var_5) = &input.tags {
let mut array_6 = object.key("tags").start_array();
for item_7 in var_5 {
{
#[allow(unused_mut)]
let mut object_8 = array_6.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_8, item_7)?;
object_8.finish();
}
}
array_6.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_get_variable_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetVariableInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_9) = &input.names {
let mut array_10 = object.key("names").start_array();
for item_11 in var_9 {
{
array_10.value().string(item_11.as_str());
}
}
array_10.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_cancel_batch_import_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CancelBatchImportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_12) = &input.job_id {
object.key("jobId").string(var_12.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_cancel_batch_prediction_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CancelBatchPredictionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_13) = &input.job_id {
object.key("jobId").string(var_13.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_batch_import_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBatchImportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_14) = &input.job_id {
object.key("jobId").string(var_14.as_str());
}
if let Some(var_15) = &input.input_path {
object.key("inputPath").string(var_15.as_str());
}
if let Some(var_16) = &input.output_path {
object.key("outputPath").string(var_16.as_str());
}
if let Some(var_17) = &input.event_type_name {
object.key("eventTypeName").string(var_17.as_str());
}
if let Some(var_18) = &input.iam_role_arn {
object.key("iamRoleArn").string(var_18.as_str());
}
if let Some(var_19) = &input.tags {
let mut array_20 = object.key("tags").start_array();
for item_21 in var_19 {
{
#[allow(unused_mut)]
let mut object_22 = array_20.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_22, item_21)?;
object_22.finish();
}
}
array_20.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_batch_prediction_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBatchPredictionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_23) = &input.job_id {
object.key("jobId").string(var_23.as_str());
}
if let Some(var_24) = &input.input_path {
object.key("inputPath").string(var_24.as_str());
}
if let Some(var_25) = &input.output_path {
object.key("outputPath").string(var_25.as_str());
}
if let Some(var_26) = &input.event_type_name {
object.key("eventTypeName").string(var_26.as_str());
}
if let Some(var_27) = &input.detector_name {
object.key("detectorName").string(var_27.as_str());
}
if let Some(var_28) = &input.detector_version {
object.key("detectorVersion").string(var_28.as_str());
}
if let Some(var_29) = &input.iam_role_arn {
object.key("iamRoleArn").string(var_29.as_str());
}
if let Some(var_30) = &input.tags {
let mut array_31 = object.key("tags").start_array();
for item_32 in var_30 {
{
#[allow(unused_mut)]
let mut object_33 = array_31.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_33, item_32)?;
object_33.finish();
}
}
array_31.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_detector_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDetectorVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_34) = &input.detector_id {
object.key("detectorId").string(var_34.as_str());
}
if let Some(var_35) = &input.description {
object.key("description").string(var_35.as_str());
}
if let Some(var_36) = &input.external_model_endpoints {
let mut array_37 = object.key("externalModelEndpoints").start_array();
for item_38 in var_36 {
{
array_37.value().string(item_38.as_str());
}
}
array_37.finish();
}
if let Some(var_39) = &input.rules {
let mut array_40 = object.key("rules").start_array();
for item_41 in var_39 {
{
#[allow(unused_mut)]
let mut object_42 = array_40.value().start_object();
crate::json_ser::serialize_structure_crate_model_rule(&mut object_42, item_41)?;
object_42.finish();
}
}
array_40.finish();
}
if let Some(var_43) = &input.model_versions {
let mut array_44 = object.key("modelVersions").start_array();
for item_45 in var_43 {
{
#[allow(unused_mut)]
let mut object_46 = array_44.value().start_object();
crate::json_ser::serialize_structure_crate_model_model_version(
&mut object_46,
item_45,
)?;
object_46.finish();
}
}
array_44.finish();
}
if let Some(var_47) = &input.rule_execution_mode {
object.key("ruleExecutionMode").string(var_47.as_str());
}
if let Some(var_48) = &input.tags {
let mut array_49 = object.key("tags").start_array();
for item_50 in var_48 {
{
#[allow(unused_mut)]
let mut object_51 = array_49.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_51, item_50)?;
object_51.finish();
}
}
array_49.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_52) = &input.model_id {
object.key("modelId").string(var_52.as_str());
}
if let Some(var_53) = &input.model_type {
object.key("modelType").string(var_53.as_str());
}
if let Some(var_54) = &input.description {
object.key("description").string(var_54.as_str());
}
if let Some(var_55) = &input.event_type_name {
object.key("eventTypeName").string(var_55.as_str());
}
if let Some(var_56) = &input.tags {
let mut array_57 = object.key("tags").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_tag(&mut object_59, item_58)?;
object_59.finish();
}
}
array_57.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_model_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateModelVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_60) = &input.model_id {
object.key("modelId").string(var_60.as_str());
}
if let Some(var_61) = &input.model_type {
object.key("modelType").string(var_61.as_str());
}
if let Some(var_62) = &input.training_data_source {
object.key("trainingDataSource").string(var_62.as_str());
}
if let Some(var_63) = &input.training_data_schema {
#[allow(unused_mut)]
let mut object_64 = object.key("trainingDataSchema").start_object();
crate::json_ser::serialize_structure_crate_model_training_data_schema(
&mut object_64,
var_63,
)?;
object_64.finish();
}
if let Some(var_65) = &input.external_events_detail {
#[allow(unused_mut)]
let mut object_66 = object.key("externalEventsDetail").start_object();
crate::json_ser::serialize_structure_crate_model_external_events_detail(
&mut object_66,
var_65,
)?;
object_66.finish();
}
if let Some(var_67) = &input.ingested_events_detail {
#[allow(unused_mut)]
let mut object_68 = object.key("ingestedEventsDetail").start_object();
crate::json_ser::serialize_structure_crate_model_ingested_events_detail(
&mut object_68,
var_67,
)?;
object_68.finish();
}
if let Some(var_69) = &input.tags {
let mut array_70 = object.key("tags").start_array();
for item_71 in var_69 {
{
#[allow(unused_mut)]
let mut object_72 = array_70.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_72, item_71)?;
object_72.finish();
}
}
array_70.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_73) = &input.rule_id {
object.key("ruleId").string(var_73.as_str());
}
if let Some(var_74) = &input.detector_id {
object.key("detectorId").string(var_74.as_str());
}
if let Some(var_75) = &input.description {
object.key("description").string(var_75.as_str());
}
if let Some(var_76) = &input.expression {
object.key("expression").string(var_76.as_str());
}
if let Some(var_77) = &input.language {
object.key("language").string(var_77.as_str());
}
if let Some(var_78) = &input.outcomes {
let mut array_79 = object.key("outcomes").start_array();
for item_80 in var_78 {
{
array_79.value().string(item_80.as_str());
}
}
array_79.finish();
}
if let Some(var_81) = &input.tags {
let mut array_82 = object.key("tags").start_array();
for item_83 in var_81 {
{
#[allow(unused_mut)]
let mut object_84 = array_82.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_84, item_83)?;
object_84.finish();
}
}
array_82.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_variable_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateVariableInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.name {
object.key("name").string(var_85.as_str());
}
if let Some(var_86) = &input.data_type {
object.key("dataType").string(var_86.as_str());
}
if let Some(var_87) = &input.data_source {
object.key("dataSource").string(var_87.as_str());
}
if let Some(var_88) = &input.default_value {
object.key("defaultValue").string(var_88.as_str());
}
if let Some(var_89) = &input.description {
object.key("description").string(var_89.as_str());
}
if let Some(var_90) = &input.variable_type {
object.key("variableType").string(var_90.as_str());
}
if let Some(var_91) = &input.tags {
let mut array_92 = object.key("tags").start_array();
for item_93 in var_91 {
{
#[allow(unused_mut)]
let mut object_94 = array_92.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_94, item_93)?;
object_94.finish();
}
}
array_92.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_batch_import_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteBatchImportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_95) = &input.job_id {
object.key("jobId").string(var_95.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_batch_prediction_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteBatchPredictionJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_96) = &input.job_id {
object.key("jobId").string(var_96.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_detector_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteDetectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_97) = &input.detector_id {
object.key("detectorId").string(var_97.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_detector_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteDetectorVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_98) = &input.detector_id {
object.key("detectorId").string(var_98.as_str());
}
if let Some(var_99) = &input.detector_version_id {
object.key("detectorVersionId").string(var_99.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_entity_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteEntityTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_100) = &input.name {
object.key("name").string(var_100.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_event_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteEventInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_101) = &input.event_id {
object.key("eventId").string(var_101.as_str());
}
if let Some(var_102) = &input.event_type_name {
object.key("eventTypeName").string(var_102.as_str());
}
if let Some(var_103) = &input.delete_audit_history {
object.key("deleteAuditHistory").boolean(*var_103);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_events_by_event_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteEventsByEventTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_104) = &input.event_type_name {
object.key("eventTypeName").string(var_104.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_event_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteEventTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_105) = &input.name {
object.key("name").string(var_105.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_external_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteExternalModelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_106) = &input.model_endpoint {
object.key("modelEndpoint").string(var_106.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_107) = &input.name {
object.key("name").string(var_107.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_108) = &input.model_id {
object.key("modelId").string(var_108.as_str());
}
if let Some(var_109) = &input.model_type {
object.key("modelType").string(var_109.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_model_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteModelVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_110) = &input.model_id {
object.key("modelId").string(var_110.as_str());
}
if let Some(var_111) = &input.model_type {
object.key("modelType").string(var_111.as_str());
}
if let Some(var_112) = &input.model_version_number {
object.key("modelVersionNumber").string(var_112.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_outcome_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteOutcomeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_113) = &input.name {
object.key("name").string(var_113.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_114) = &input.rule {
#[allow(unused_mut)]
let mut object_115 = object.key("rule").start_object();
crate::json_ser::serialize_structure_crate_model_rule(&mut object_115, var_114)?;
object_115.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_variable_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteVariableInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_116) = &input.name {
object.key("name").string(var_116.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_detector_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDetectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_117) = &input.detector_id {
object.key("detectorId").string(var_117.as_str());
}
if let Some(var_118) = &input.next_token {
object.key("nextToken").string(var_118.as_str());
}
if let Some(var_119) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_119).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_model_versions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeModelVersionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_120) = &input.model_id {
object.key("modelId").string(var_120.as_str());
}
if let Some(var_121) = &input.model_version_number {
object.key("modelVersionNumber").string(var_121.as_str());
}
if let Some(var_122) = &input.model_type {
object.key("modelType").string(var_122.as_str());
}
if let Some(var_123) = &input.next_token {
object.key("nextToken").string(var_123.as_str());
}
if let Some(var_124) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_124).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_batch_import_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetBatchImportJobsInput,
) -> 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());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_batch_prediction_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetBatchPredictionJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_128) = &input.job_id {
object.key("jobId").string(var_128.as_str());
}
if let Some(var_129) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_129).into()),
);
}
if let Some(var_130) = &input.next_token {
object.key("nextToken").string(var_130.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_delete_events_by_event_type_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetDeleteEventsByEventTypeStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_131) = &input.event_type_name {
object.key("eventTypeName").string(var_131.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_detectors_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetDetectorsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_132) = &input.detector_id {
object.key("detectorId").string(var_132.as_str());
}
if let Some(var_133) = &input.next_token {
object.key("nextToken").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()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_detector_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetDetectorVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_135) = &input.detector_id {
object.key("detectorId").string(var_135.as_str());
}
if let Some(var_136) = &input.detector_version_id {
object.key("detectorVersionId").string(var_136.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_entity_types_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetEntityTypesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_137) = &input.name {
object.key("name").string(var_137.as_str());
}
if let Some(var_138) = &input.next_token {
object.key("nextToken").string(var_138.as_str());
}
if let Some(var_139) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_139).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_event_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetEventInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_140) = &input.event_id {
object.key("eventId").string(var_140.as_str());
}
if let Some(var_141) = &input.event_type_name {
object.key("eventTypeName").string(var_141.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_event_prediction_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetEventPredictionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_142) = &input.detector_id {
object.key("detectorId").string(var_142.as_str());
}
if let Some(var_143) = &input.detector_version_id {
object.key("detectorVersionId").string(var_143.as_str());
}
if let Some(var_144) = &input.event_id {
object.key("eventId").string(var_144.as_str());
}
if let Some(var_145) = &input.event_type_name {
object.key("eventTypeName").string(var_145.as_str());
}
if let Some(var_146) = &input.entities {
let mut array_147 = object.key("entities").start_array();
for item_148 in var_146 {
{
#[allow(unused_mut)]
let mut object_149 = array_147.value().start_object();
crate::json_ser::serialize_structure_crate_model_entity(&mut object_149, item_148)?;
object_149.finish();
}
}
array_147.finish();
}
if let Some(var_150) = &input.event_timestamp {
object.key("eventTimestamp").string(var_150.as_str());
}
if let Some(var_151) = &input.event_variables {
#[allow(unused_mut)]
let mut object_152 = object.key("eventVariables").start_object();
for (key_153, value_154) in var_151 {
{
object_152.key(key_153.as_str()).string(value_154.as_str());
}
}
object_152.finish();
}
if let Some(var_155) = &input.external_model_endpoint_data_blobs {
#[allow(unused_mut)]
let mut object_156 = object.key("externalModelEndpointDataBlobs").start_object();
for (key_157, value_158) in var_155 {
{
#[allow(unused_mut)]
let mut object_159 = object_156.key(key_157.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_model_endpoint_data_blob(
&mut object_159,
value_158,
)?;
object_159.finish();
}
}
object_156.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_event_prediction_metadata_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetEventPredictionMetadataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_160) = &input.event_id {
object.key("eventId").string(var_160.as_str());
}
if let Some(var_161) = &input.event_type_name {
object.key("eventTypeName").string(var_161.as_str());
}
if let Some(var_162) = &input.detector_id {
object.key("detectorId").string(var_162.as_str());
}
if let Some(var_163) = &input.detector_version_id {
object.key("detectorVersionId").string(var_163.as_str());
}
if let Some(var_164) = &input.prediction_timestamp {
object.key("predictionTimestamp").string(var_164.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_event_types_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetEventTypesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_165) = &input.name {
object.key("name").string(var_165.as_str());
}
if let Some(var_166) = &input.next_token {
object.key("nextToken").string(var_166.as_str());
}
if let Some(var_167) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_167).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_external_models_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetExternalModelsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_168) = &input.model_endpoint {
object.key("modelEndpoint").string(var_168.as_str());
}
if let Some(var_169) = &input.next_token {
object.key("nextToken").string(var_169.as_str());
}
if let Some(var_170) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_170).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_labels_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetLabelsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_171) = &input.name {
object.key("name").string(var_171.as_str());
}
if let Some(var_172) = &input.next_token {
object.key("nextToken").string(var_172.as_str());
}
if let Some(var_173) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_173).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_models_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetModelsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_174) = &input.model_id {
object.key("modelId").string(var_174.as_str());
}
if let Some(var_175) = &input.model_type {
object.key("modelType").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_get_model_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetModelVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_178) = &input.model_id {
object.key("modelId").string(var_178.as_str());
}
if let Some(var_179) = &input.model_type {
object.key("modelType").string(var_179.as_str());
}
if let Some(var_180) = &input.model_version_number {
object.key("modelVersionNumber").string(var_180.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_outcomes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetOutcomesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_181) = &input.name {
object.key("name").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_get_rules_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetRulesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_184) = &input.rule_id {
object.key("ruleId").string(var_184.as_str());
}
if let Some(var_185) = &input.detector_id {
object.key("detectorId").string(var_185.as_str());
}
if let Some(var_186) = &input.rule_version {
object.key("ruleVersion").string(var_186.as_str());
}
if let Some(var_187) = &input.next_token {
object.key("nextToken").string(var_187.as_str());
}
if let Some(var_188) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_188).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_variables_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetVariablesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_189) = &input.name {
object.key("name").string(var_189.as_str());
}
if let Some(var_190) = &input.next_token {
object.key("nextToken").string(var_190.as_str());
}
if let Some(var_191) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_191).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_event_predictions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListEventPredictionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_192) = &input.event_id {
#[allow(unused_mut)]
let mut object_193 = object.key("eventId").start_object();
crate::json_ser::serialize_structure_crate_model_filter_condition(
&mut object_193,
var_192,
)?;
object_193.finish();
}
if let Some(var_194) = &input.event_type {
#[allow(unused_mut)]
let mut object_195 = object.key("eventType").start_object();
crate::json_ser::serialize_structure_crate_model_filter_condition(
&mut object_195,
var_194,
)?;
object_195.finish();
}
if let Some(var_196) = &input.detector_id {
#[allow(unused_mut)]
let mut object_197 = object.key("detectorId").start_object();
crate::json_ser::serialize_structure_crate_model_filter_condition(
&mut object_197,
var_196,
)?;
object_197.finish();
}
if let Some(var_198) = &input.detector_version_id {
#[allow(unused_mut)]
let mut object_199 = object.key("detectorVersionId").start_object();
crate::json_ser::serialize_structure_crate_model_filter_condition(
&mut object_199,
var_198,
)?;
object_199.finish();
}
if let Some(var_200) = &input.prediction_time_range {
#[allow(unused_mut)]
let mut object_201 = object.key("predictionTimeRange").start_object();
crate::json_ser::serialize_structure_crate_model_prediction_time_range(
&mut object_201,
var_200,
)?;
object_201.finish();
}
if let Some(var_202) = &input.next_token {
object.key("nextToken").string(var_202.as_str());
}
if let Some(var_203) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_203).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_204) = &input.resource_arn {
object.key("resourceARN").string(var_204.as_str());
}
if let Some(var_205) = &input.next_token {
object.key("nextToken").string(var_205.as_str());
}
if let Some(var_206) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_206).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_detector_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutDetectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_207) = &input.detector_id {
object.key("detectorId").string(var_207.as_str());
}
if let Some(var_208) = &input.description {
object.key("description").string(var_208.as_str());
}
if let Some(var_209) = &input.event_type_name {
object.key("eventTypeName").string(var_209.as_str());
}
if let Some(var_210) = &input.tags {
let mut array_211 = object.key("tags").start_array();
for item_212 in var_210 {
{
#[allow(unused_mut)]
let mut object_213 = array_211.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_213, item_212)?;
object_213.finish();
}
}
array_211.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_entity_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutEntityTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_214) = &input.name {
object.key("name").string(var_214.as_str());
}
if let Some(var_215) = &input.description {
object.key("description").string(var_215.as_str());
}
if let Some(var_216) = &input.tags {
let mut array_217 = object.key("tags").start_array();
for item_218 in var_216 {
{
#[allow(unused_mut)]
let mut object_219 = array_217.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_219, item_218)?;
object_219.finish();
}
}
array_217.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_event_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutEventTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_220) = &input.name {
object.key("name").string(var_220.as_str());
}
if let Some(var_221) = &input.description {
object.key("description").string(var_221.as_str());
}
if let Some(var_222) = &input.event_variables {
let mut array_223 = object.key("eventVariables").start_array();
for item_224 in var_222 {
{
array_223.value().string(item_224.as_str());
}
}
array_223.finish();
}
if let Some(var_225) = &input.labels {
let mut array_226 = object.key("labels").start_array();
for item_227 in var_225 {
{
array_226.value().string(item_227.as_str());
}
}
array_226.finish();
}
if let Some(var_228) = &input.entity_types {
let mut array_229 = object.key("entityTypes").start_array();
for item_230 in var_228 {
{
array_229.value().string(item_230.as_str());
}
}
array_229.finish();
}
if let Some(var_231) = &input.event_ingestion {
object.key("eventIngestion").string(var_231.as_str());
}
if let Some(var_232) = &input.tags {
let mut array_233 = object.key("tags").start_array();
for item_234 in var_232 {
{
#[allow(unused_mut)]
let mut object_235 = array_233.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_235, item_234)?;
object_235.finish();
}
}
array_233.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_external_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutExternalModelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_236) = &input.model_endpoint {
object.key("modelEndpoint").string(var_236.as_str());
}
if let Some(var_237) = &input.model_source {
object.key("modelSource").string(var_237.as_str());
}
if let Some(var_238) = &input.invoke_model_endpoint_role_arn {
object
.key("invokeModelEndpointRoleArn")
.string(var_238.as_str());
}
if let Some(var_239) = &input.input_configuration {
#[allow(unused_mut)]
let mut object_240 = object.key("inputConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_model_input_configuration(
&mut object_240,
var_239,
)?;
object_240.finish();
}
if let Some(var_241) = &input.output_configuration {
#[allow(unused_mut)]
let mut object_242 = object.key("outputConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_model_output_configuration(
&mut object_242,
var_241,
)?;
object_242.finish();
}
if let Some(var_243) = &input.model_endpoint_status {
object.key("modelEndpointStatus").string(var_243.as_str());
}
if let Some(var_244) = &input.tags {
let mut array_245 = object.key("tags").start_array();
for item_246 in var_244 {
{
#[allow(unused_mut)]
let mut object_247 = array_245.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_247, item_246)?;
object_247.finish();
}
}
array_245.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_kms_encryption_key_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutKmsEncryptionKeyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_248) = &input.kms_encryption_key_arn {
object.key("kmsEncryptionKeyArn").string(var_248.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_label_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutLabelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_249) = &input.name {
object.key("name").string(var_249.as_str());
}
if let Some(var_250) = &input.description {
object.key("description").string(var_250.as_str());
}
if let Some(var_251) = &input.tags {
let mut array_252 = object.key("tags").start_array();
for item_253 in var_251 {
{
#[allow(unused_mut)]
let mut object_254 = array_252.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_254, item_253)?;
object_254.finish();
}
}
array_252.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_outcome_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutOutcomeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_255) = &input.name {
object.key("name").string(var_255.as_str());
}
if let Some(var_256) = &input.description {
object.key("description").string(var_256.as_str());
}
if let Some(var_257) = &input.tags {
let mut array_258 = object.key("tags").start_array();
for item_259 in var_257 {
{
#[allow(unused_mut)]
let mut object_260 = array_258.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_260, item_259)?;
object_260.finish();
}
}
array_258.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_send_event_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SendEventInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_261) = &input.event_id {
object.key("eventId").string(var_261.as_str());
}
if let Some(var_262) = &input.event_type_name {
object.key("eventTypeName").string(var_262.as_str());
}
if let Some(var_263) = &input.event_timestamp {
object.key("eventTimestamp").string(var_263.as_str());
}
if let Some(var_264) = &input.event_variables {
#[allow(unused_mut)]
let mut object_265 = object.key("eventVariables").start_object();
for (key_266, value_267) in var_264 {
{
object_265.key(key_266.as_str()).string(value_267.as_str());
}
}
object_265.finish();
}
if let Some(var_268) = &input.assigned_label {
object.key("assignedLabel").string(var_268.as_str());
}
if let Some(var_269) = &input.label_timestamp {
object.key("labelTimestamp").string(var_269.as_str());
}
if let Some(var_270) = &input.entities {
let mut array_271 = object.key("entities").start_array();
for item_272 in var_270 {
{
#[allow(unused_mut)]
let mut object_273 = array_271.value().start_object();
crate::json_ser::serialize_structure_crate_model_entity(&mut object_273, item_272)?;
object_273.finish();
}
}
array_271.finish();
}
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_274) = &input.resource_arn {
object.key("resourceARN").string(var_274.as_str());
}
if let Some(var_275) = &input.tags {
let mut array_276 = object.key("tags").start_array();
for item_277 in var_275 {
{
#[allow(unused_mut)]
let mut object_278 = array_276.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_278, item_277)?;
object_278.finish();
}
}
array_276.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_279) = &input.resource_arn {
object.key("resourceARN").string(var_279.as_str());
}
if let Some(var_280) = &input.tag_keys {
let mut array_281 = object.key("tagKeys").start_array();
for item_282 in var_280 {
{
array_281.value().string(item_282.as_str());
}
}
array_281.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_detector_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDetectorVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_283) = &input.detector_id {
object.key("detectorId").string(var_283.as_str());
}
if let Some(var_284) = &input.detector_version_id {
object.key("detectorVersionId").string(var_284.as_str());
}
if let Some(var_285) = &input.external_model_endpoints {
let mut array_286 = object.key("externalModelEndpoints").start_array();
for item_287 in var_285 {
{
array_286.value().string(item_287.as_str());
}
}
array_286.finish();
}
if let Some(var_288) = &input.rules {
let mut array_289 = object.key("rules").start_array();
for item_290 in var_288 {
{
#[allow(unused_mut)]
let mut object_291 = array_289.value().start_object();
crate::json_ser::serialize_structure_crate_model_rule(&mut object_291, item_290)?;
object_291.finish();
}
}
array_289.finish();
}
if let Some(var_292) = &input.description {
object.key("description").string(var_292.as_str());
}
if let Some(var_293) = &input.model_versions {
let mut array_294 = object.key("modelVersions").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_model_version(
&mut object_296,
item_295,
)?;
object_296.finish();
}
}
array_294.finish();
}
if let Some(var_297) = &input.rule_execution_mode {
object.key("ruleExecutionMode").string(var_297.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_detector_version_metadata_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDetectorVersionMetadataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_298) = &input.detector_id {
object.key("detectorId").string(var_298.as_str());
}
if let Some(var_299) = &input.detector_version_id {
object.key("detectorVersionId").string(var_299.as_str());
}
if let Some(var_300) = &input.description {
object.key("description").string(var_300.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_detector_version_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDetectorVersionStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_301) = &input.detector_id {
object.key("detectorId").string(var_301.as_str());
}
if let Some(var_302) = &input.detector_version_id {
object.key("detectorVersionId").string(var_302.as_str());
}
if let Some(var_303) = &input.status {
object.key("status").string(var_303.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_event_label_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateEventLabelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_304) = &input.event_id {
object.key("eventId").string(var_304.as_str());
}
if let Some(var_305) = &input.event_type_name {
object.key("eventTypeName").string(var_305.as_str());
}
if let Some(var_306) = &input.assigned_label {
object.key("assignedLabel").string(var_306.as_str());
}
if let Some(var_307) = &input.label_timestamp {
object.key("labelTimestamp").string(var_307.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateModelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_308) = &input.model_id {
object.key("modelId").string(var_308.as_str());
}
if let Some(var_309) = &input.model_type {
object.key("modelType").string(var_309.as_str());
}
if let Some(var_310) = &input.description {
object.key("description").string(var_310.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_model_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateModelVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_311) = &input.model_id {
object.key("modelId").string(var_311.as_str());
}
if let Some(var_312) = &input.model_type {
object.key("modelType").string(var_312.as_str());
}
if let Some(var_313) = &input.major_version_number {
object.key("majorVersionNumber").string(var_313.as_str());
}
if let Some(var_314) = &input.external_events_detail {
#[allow(unused_mut)]
let mut object_315 = object.key("externalEventsDetail").start_object();
crate::json_ser::serialize_structure_crate_model_external_events_detail(
&mut object_315,
var_314,
)?;
object_315.finish();
}
if let Some(var_316) = &input.ingested_events_detail {
#[allow(unused_mut)]
let mut object_317 = object.key("ingestedEventsDetail").start_object();
crate::json_ser::serialize_structure_crate_model_ingested_events_detail(
&mut object_317,
var_316,
)?;
object_317.finish();
}
if let Some(var_318) = &input.tags {
let mut array_319 = object.key("tags").start_array();
for item_320 in var_318 {
{
#[allow(unused_mut)]
let mut object_321 = array_319.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_321, item_320)?;
object_321.finish();
}
}
array_319.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_model_version_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateModelVersionStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_322) = &input.model_id {
object.key("modelId").string(var_322.as_str());
}
if let Some(var_323) = &input.model_type {
object.key("modelType").string(var_323.as_str());
}
if let Some(var_324) = &input.model_version_number {
object.key("modelVersionNumber").string(var_324.as_str());
}
if let Some(var_325) = &input.status {
object.key("status").string(var_325.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_rule_metadata_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRuleMetadataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_326) = &input.rule {
#[allow(unused_mut)]
let mut object_327 = object.key("rule").start_object();
crate::json_ser::serialize_structure_crate_model_rule(&mut object_327, var_326)?;
object_327.finish();
}
if let Some(var_328) = &input.description {
object.key("description").string(var_328.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_rule_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRuleVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_329) = &input.rule {
#[allow(unused_mut)]
let mut object_330 = object.key("rule").start_object();
crate::json_ser::serialize_structure_crate_model_rule(&mut object_330, var_329)?;
object_330.finish();
}
if let Some(var_331) = &input.description {
object.key("description").string(var_331.as_str());
}
if let Some(var_332) = &input.expression {
object.key("expression").string(var_332.as_str());
}
if let Some(var_333) = &input.language {
object.key("language").string(var_333.as_str());
}
if let Some(var_334) = &input.outcomes {
let mut array_335 = object.key("outcomes").start_array();
for item_336 in var_334 {
{
array_335.value().string(item_336.as_str());
}
}
array_335.finish();
}
if let Some(var_337) = &input.tags {
let mut array_338 = object.key("tags").start_array();
for item_339 in var_337 {
{
#[allow(unused_mut)]
let mut object_340 = array_338.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_340, item_339)?;
object_340.finish();
}
}
array_338.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_variable_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateVariableInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_341) = &input.name {
object.key("name").string(var_341.as_str());
}
if let Some(var_342) = &input.default_value {
object.key("defaultValue").string(var_342.as_str());
}
if let Some(var_343) = &input.description {
object.key("description").string(var_343.as_str());
}
if let Some(var_344) = &input.variable_type {
object.key("variableType").string(var_344.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_variable_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VariableEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_345) = &input.name {
object.key("name").string(var_345.as_str());
}
if let Some(var_346) = &input.data_type {
object.key("dataType").string(var_346.as_str());
}
if let Some(var_347) = &input.data_source {
object.key("dataSource").string(var_347.as_str());
}
if let Some(var_348) = &input.default_value {
object.key("defaultValue").string(var_348.as_str());
}
if let Some(var_349) = &input.description {
object.key("description").string(var_349.as_str());
}
if let Some(var_350) = &input.variable_type {
object.key("variableType").string(var_350.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_351) = &input.key {
object.key("key").string(var_351.as_str());
}
if let Some(var_352) = &input.value {
object.key("value").string(var_352.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Rule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_353) = &input.detector_id {
object.key("detectorId").string(var_353.as_str());
}
if let Some(var_354) = &input.rule_id {
object.key("ruleId").string(var_354.as_str());
}
if let Some(var_355) = &input.rule_version {
object.key("ruleVersion").string(var_355.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_model_version(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelVersion,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_356) = &input.model_id {
object.key("modelId").string(var_356.as_str());
}
if let Some(var_357) = &input.model_type {
object.key("modelType").string(var_357.as_str());
}
if let Some(var_358) = &input.model_version_number {
object.key("modelVersionNumber").string(var_358.as_str());
}
if let Some(var_359) = &input.arn {
object.key("arn").string(var_359.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_training_data_schema(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TrainingDataSchema,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_360) = &input.model_variables {
let mut array_361 = object.key("modelVariables").start_array();
for item_362 in var_360 {
{
array_361.value().string(item_362.as_str());
}
}
array_361.finish();
}
if let Some(var_363) = &input.label_schema {
#[allow(unused_mut)]
let mut object_364 = object.key("labelSchema").start_object();
crate::json_ser::serialize_structure_crate_model_label_schema(&mut object_364, var_363)?;
object_364.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_external_events_detail(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExternalEventsDetail,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_365) = &input.data_location {
object.key("dataLocation").string(var_365.as_str());
}
if let Some(var_366) = &input.data_access_role_arn {
object.key("dataAccessRoleArn").string(var_366.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ingested_events_detail(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IngestedEventsDetail,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_367) = &input.ingested_events_time_window {
#[allow(unused_mut)]
let mut object_368 = object.key("ingestedEventsTimeWindow").start_object();
crate::json_ser::serialize_structure_crate_model_ingested_events_time_window(
&mut object_368,
var_367,
)?;
object_368.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_entity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Entity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_369) = &input.entity_type {
object.key("entityType").string(var_369.as_str());
}
if let Some(var_370) = &input.entity_id {
object.key("entityId").string(var_370.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_model_endpoint_data_blob(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelEndpointDataBlob,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_371) = &input.byte_buffer {
object
.key("byteBuffer")
.string_unchecked(&aws_smithy_types::base64::encode(var_371));
}
if let Some(var_372) = &input.content_type {
object.key("contentType").string(var_372.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterCondition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_373) = &input.value {
object.key("value").string(var_373.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_prediction_time_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PredictionTimeRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_374) = &input.start_time {
object.key("startTime").string(var_374.as_str());
}
if let Some(var_375) = &input.end_time {
object.key("endTime").string(var_375.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_model_input_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelInputConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_376) = &input.event_type_name {
object.key("eventTypeName").string(var_376.as_str());
}
if let Some(var_377) = &input.format {
object.key("format").string(var_377.as_str());
}
if let Some(var_378) = &input.use_event_variables {
object.key("useEventVariables").boolean(*var_378);
}
if let Some(var_379) = &input.json_input_template {
object.key("jsonInputTemplate").string(var_379.as_str());
}
if let Some(var_380) = &input.csv_input_template {
object.key("csvInputTemplate").string(var_380.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_model_output_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ModelOutputConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_381) = &input.format {
object.key("format").string(var_381.as_str());
}
if let Some(var_382) = &input.json_key_to_variable_map {
#[allow(unused_mut)]
let mut object_383 = object.key("jsonKeyToVariableMap").start_object();
for (key_384, value_385) in var_382 {
{
object_383.key(key_384.as_str()).string(value_385.as_str());
}
}
object_383.finish();
}
if let Some(var_386) = &input.csv_index_to_variable_map {
#[allow(unused_mut)]
let mut object_387 = object.key("csvIndexToVariableMap").start_object();
for (key_388, value_389) in var_386 {
{
object_387.key(key_388.as_str()).string(value_389.as_str());
}
}
object_387.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_label_schema(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LabelSchema,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_390) = &input.label_mapper {
#[allow(unused_mut)]
let mut object_391 = object.key("labelMapper").start_object();
for (key_392, value_393) in var_390 {
{
let mut array_394 = object_391.key(key_392.as_str()).start_array();
for item_395 in value_393 {
{
array_394.value().string(item_395.as_str());
}
}
array_394.finish();
}
}
object_391.finish();
}
if let Some(var_396) = &input.unlabeled_events_treatment {
object
.key("unlabeledEventsTreatment")
.string(var_396.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ingested_events_time_window(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IngestedEventsTimeWindow,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_397) = &input.start_time {
object.key("startTime").string(var_397.as_str());
}
if let Some(var_398) = &input.end_time {
object.key("endTime").string(var_398.as_str());
}
Ok(())
}