pub fn serialize_structure_crate_input_create_alarm_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAlarmModelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.alarm_capabilities {
#[allow(unused_mut)]
let mut object_2 = object.key("alarmCapabilities").start_object();
crate::json_ser::serialize_structure_crate_model_alarm_capabilities(&mut object_2, var_1)?;
object_2.finish();
}
if let Some(var_3) = &input.alarm_event_actions {
#[allow(unused_mut)]
let mut object_4 = object.key("alarmEventActions").start_object();
crate::json_ser::serialize_structure_crate_model_alarm_event_actions(&mut object_4, var_3)?;
object_4.finish();
}
if let Some(var_5) = &input.alarm_model_description {
object.key("alarmModelDescription").string(var_5.as_str());
}
if let Some(var_6) = &input.alarm_model_name {
object.key("alarmModelName").string(var_6.as_str());
}
if let Some(var_7) = &input.alarm_notification {
#[allow(unused_mut)]
let mut object_8 = object.key("alarmNotification").start_object();
crate::json_ser::serialize_structure_crate_model_alarm_notification(&mut object_8, var_7)?;
object_8.finish();
}
if let Some(var_9) = &input.alarm_rule {
#[allow(unused_mut)]
let mut object_10 = object.key("alarmRule").start_object();
crate::json_ser::serialize_structure_crate_model_alarm_rule(&mut object_10, var_9)?;
object_10.finish();
}
if let Some(var_11) = &input.key {
object.key("key").string(var_11.as_str());
}
if let Some(var_12) = &input.role_arn {
object.key("roleArn").string(var_12.as_str());
}
if let Some(var_13) = &input.severity {
object.key("severity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_13).into()),
);
}
if let Some(var_14) = &input.tags {
let mut array_15 = object.key("tags").start_array();
for item_16 in var_14 {
{
#[allow(unused_mut)]
let mut object_17 = array_15.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_17, item_16)?;
object_17.finish();
}
}
array_15.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_detector_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDetectorModelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_18) = &input.detector_model_definition {
#[allow(unused_mut)]
let mut object_19 = object.key("detectorModelDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_detector_model_definition(
&mut object_19,
var_18,
)?;
object_19.finish();
}
if let Some(var_20) = &input.detector_model_description {
object
.key("detectorModelDescription")
.string(var_20.as_str());
}
if let Some(var_21) = &input.detector_model_name {
object.key("detectorModelName").string(var_21.as_str());
}
if let Some(var_22) = &input.evaluation_method {
object.key("evaluationMethod").string(var_22.as_str());
}
if let Some(var_23) = &input.key {
object.key("key").string(var_23.as_str());
}
if let Some(var_24) = &input.role_arn {
object.key("roleArn").string(var_24.as_str());
}
if let Some(var_25) = &input.tags {
let mut array_26 = object.key("tags").start_array();
for item_27 in var_25 {
{
#[allow(unused_mut)]
let mut object_28 = array_26.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_28, item_27)?;
object_28.finish();
}
}
array_26.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_input_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateInputInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_29) = &input.input_definition {
#[allow(unused_mut)]
let mut object_30 = object.key("inputDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_input_definition(&mut object_30, var_29)?;
object_30.finish();
}
if let Some(var_31) = &input.input_description {
object.key("inputDescription").string(var_31.as_str());
}
if let Some(var_32) = &input.input_name {
object.key("inputName").string(var_32.as_str());
}
if let Some(var_33) = &input.tags {
let mut array_34 = object.key("tags").start_array();
for item_35 in var_33 {
{
#[allow(unused_mut)]
let mut object_36 = array_34.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_36, item_35)?;
object_36.finish();
}
}
array_34.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_input_routings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListInputRoutingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_37) = &input.input_identifier {
#[allow(unused_mut)]
let mut object_38 = object.key("inputIdentifier").start_object();
crate::json_ser::serialize_structure_crate_model_input_identifier(&mut object_38, var_37)?;
object_38.finish();
}
if let Some(var_39) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_39).into()),
);
}
if let Some(var_40) = &input.next_token {
object.key("nextToken").string(var_40.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_logging_options_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutLoggingOptionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_41) = &input.logging_options {
#[allow(unused_mut)]
let mut object_42 = object.key("loggingOptions").start_object();
crate::json_ser::serialize_structure_crate_model_logging_options(&mut object_42, var_41)?;
object_42.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_detector_model_analysis_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartDetectorModelAnalysisInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_43) = &input.detector_model_definition {
#[allow(unused_mut)]
let mut object_44 = object.key("detectorModelDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_detector_model_definition(
&mut object_44,
var_43,
)?;
object_44.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_45) = &input.tags {
let mut array_46 = object.key("tags").start_array();
for item_47 in var_45 {
{
#[allow(unused_mut)]
let mut object_48 = array_46.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_48, item_47)?;
object_48.finish();
}
}
array_46.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_alarm_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAlarmModelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_49) = &input.alarm_capabilities {
#[allow(unused_mut)]
let mut object_50 = object.key("alarmCapabilities").start_object();
crate::json_ser::serialize_structure_crate_model_alarm_capabilities(
&mut object_50,
var_49,
)?;
object_50.finish();
}
if let Some(var_51) = &input.alarm_event_actions {
#[allow(unused_mut)]
let mut object_52 = object.key("alarmEventActions").start_object();
crate::json_ser::serialize_structure_crate_model_alarm_event_actions(
&mut object_52,
var_51,
)?;
object_52.finish();
}
if let Some(var_53) = &input.alarm_model_description {
object.key("alarmModelDescription").string(var_53.as_str());
}
if let Some(var_54) = &input.alarm_notification {
#[allow(unused_mut)]
let mut object_55 = object.key("alarmNotification").start_object();
crate::json_ser::serialize_structure_crate_model_alarm_notification(
&mut object_55,
var_54,
)?;
object_55.finish();
}
if let Some(var_56) = &input.alarm_rule {
#[allow(unused_mut)]
let mut object_57 = object.key("alarmRule").start_object();
crate::json_ser::serialize_structure_crate_model_alarm_rule(&mut object_57, var_56)?;
object_57.finish();
}
if let Some(var_58) = &input.role_arn {
object.key("roleArn").string(var_58.as_str());
}
if let Some(var_59) = &input.severity {
object.key("severity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_59).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_detector_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDetectorModelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_60) = &input.detector_model_definition {
#[allow(unused_mut)]
let mut object_61 = object.key("detectorModelDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_detector_model_definition(
&mut object_61,
var_60,
)?;
object_61.finish();
}
if let Some(var_62) = &input.detector_model_description {
object
.key("detectorModelDescription")
.string(var_62.as_str());
}
if let Some(var_63) = &input.evaluation_method {
object.key("evaluationMethod").string(var_63.as_str());
}
if let Some(var_64) = &input.role_arn {
object.key("roleArn").string(var_64.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_input_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateInputInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_65) = &input.input_definition {
#[allow(unused_mut)]
let mut object_66 = object.key("inputDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_input_definition(&mut object_66, var_65)?;
object_66.finish();
}
if let Some(var_67) = &input.input_description {
object.key("inputDescription").string(var_67.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_alarm_capabilities(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AlarmCapabilities,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_68) = &input.initialization_configuration {
#[allow(unused_mut)]
let mut object_69 = object.key("initializationConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_initialization_configuration(
&mut object_69,
var_68,
)?;
object_69.finish();
}
if let Some(var_70) = &input.acknowledge_flow {
#[allow(unused_mut)]
let mut object_71 = object.key("acknowledgeFlow").start_object();
crate::json_ser::serialize_structure_crate_model_acknowledge_flow(&mut object_71, var_70)?;
object_71.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_alarm_event_actions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AlarmEventActions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_72) = &input.alarm_actions {
let mut array_73 = object.key("alarmActions").start_array();
for item_74 in var_72 {
{
#[allow(unused_mut)]
let mut object_75 = array_73.value().start_object();
crate::json_ser::serialize_structure_crate_model_alarm_action(
&mut object_75,
item_74,
)?;
object_75.finish();
}
}
array_73.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_alarm_notification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AlarmNotification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_76) = &input.notification_actions {
let mut array_77 = object.key("notificationActions").start_array();
for item_78 in var_76 {
{
#[allow(unused_mut)]
let mut object_79 = array_77.value().start_object();
crate::json_ser::serialize_structure_crate_model_notification_action(
&mut object_79,
item_78,
)?;
object_79.finish();
}
}
array_77.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_alarm_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AlarmRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_80) = &input.simple_rule {
#[allow(unused_mut)]
let mut object_81 = object.key("simpleRule").start_object();
crate::json_ser::serialize_structure_crate_model_simple_rule(&mut object_81, var_80)?;
object_81.finish();
}
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_82) = &input.key {
object.key("key").string(var_82.as_str());
}
if let Some(var_83) = &input.value {
object.key("value").string(var_83.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_detector_model_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DetectorModelDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_84) = &input.states {
let mut array_85 = object.key("states").start_array();
for item_86 in var_84 {
{
#[allow(unused_mut)]
let mut object_87 = array_85.value().start_object();
crate::json_ser::serialize_structure_crate_model_state(&mut object_87, item_86)?;
object_87.finish();
}
}
array_85.finish();
}
if let Some(var_88) = &input.initial_state_name {
object.key("initialStateName").string(var_88.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_input_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InputDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.attributes {
let mut array_90 = object.key("attributes").start_array();
for item_91 in var_89 {
{
#[allow(unused_mut)]
let mut object_92 = array_90.value().start_object();
crate::json_ser::serialize_structure_crate_model_attribute(
&mut object_92,
item_91,
)?;
object_92.finish();
}
}
array_90.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_input_identifier(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InputIdentifier,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.iot_events_input_identifier {
#[allow(unused_mut)]
let mut object_94 = object.key("iotEventsInputIdentifier").start_object();
crate::json_ser::serialize_structure_crate_model_iot_events_input_identifier(
&mut object_94,
var_93,
)?;
object_94.finish();
}
if let Some(var_95) = &input.iot_site_wise_input_identifier {
#[allow(unused_mut)]
let mut object_96 = object.key("iotSiteWiseInputIdentifier").start_object();
crate::json_ser::serialize_structure_crate_model_iot_site_wise_input_identifier(
&mut object_96,
var_95,
)?;
object_96.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_logging_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoggingOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_97) = &input.role_arn {
object.key("roleArn").string(var_97.as_str());
}
if let Some(var_98) = &input.level {
object.key("level").string(var_98.as_str());
}
{
object.key("enabled").boolean(input.enabled);
}
if let Some(var_99) = &input.detector_debug_options {
let mut array_100 = object.key("detectorDebugOptions").start_array();
for item_101 in var_99 {
{
#[allow(unused_mut)]
let mut object_102 = array_100.value().start_object();
crate::json_ser::serialize_structure_crate_model_detector_debug_option(
&mut object_102,
item_101,
)?;
object_102.finish();
}
}
array_100.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_initialization_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InitializationConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_103) = &input.disabled_on_initialization {
object.key("disabledOnInitialization").boolean(*var_103);
}
Ok(())
}
pub fn serialize_structure_crate_model_acknowledge_flow(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AcknowledgeFlow,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_104) = &input.enabled {
object.key("enabled").boolean(*var_104);
}
Ok(())
}
pub fn serialize_structure_crate_model_alarm_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AlarmAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_105) = &input.sns {
#[allow(unused_mut)]
let mut object_106 = object.key("sns").start_object();
crate::json_ser::serialize_structure_crate_model_sns_topic_publish_action(
&mut object_106,
var_105,
)?;
object_106.finish();
}
if let Some(var_107) = &input.iot_topic_publish {
#[allow(unused_mut)]
let mut object_108 = object.key("iotTopicPublish").start_object();
crate::json_ser::serialize_structure_crate_model_iot_topic_publish_action(
&mut object_108,
var_107,
)?;
object_108.finish();
}
if let Some(var_109) = &input.lambda {
#[allow(unused_mut)]
let mut object_110 = object.key("lambda").start_object();
crate::json_ser::serialize_structure_crate_model_lambda_action(&mut object_110, var_109)?;
object_110.finish();
}
if let Some(var_111) = &input.iot_events {
#[allow(unused_mut)]
let mut object_112 = object.key("iotEvents").start_object();
crate::json_ser::serialize_structure_crate_model_iot_events_action(
&mut object_112,
var_111,
)?;
object_112.finish();
}
if let Some(var_113) = &input.sqs {
#[allow(unused_mut)]
let mut object_114 = object.key("sqs").start_object();
crate::json_ser::serialize_structure_crate_model_sqs_action(&mut object_114, var_113)?;
object_114.finish();
}
if let Some(var_115) = &input.firehose {
#[allow(unused_mut)]
let mut object_116 = object.key("firehose").start_object();
crate::json_ser::serialize_structure_crate_model_firehose_action(&mut object_116, var_115)?;
object_116.finish();
}
if let Some(var_117) = &input.dynamo_db {
#[allow(unused_mut)]
let mut object_118 = object.key("dynamoDB").start_object();
crate::json_ser::serialize_structure_crate_model_dynamo_db_action(
&mut object_118,
var_117,
)?;
object_118.finish();
}
if let Some(var_119) = &input.dynamo_d_bv2 {
#[allow(unused_mut)]
let mut object_120 = object.key("dynamoDBv2").start_object();
crate::json_ser::serialize_structure_crate_model_dynamo_d_bv2_action(
&mut object_120,
var_119,
)?;
object_120.finish();
}
if let Some(var_121) = &input.iot_site_wise {
#[allow(unused_mut)]
let mut object_122 = object.key("iotSiteWise").start_object();
crate::json_ser::serialize_structure_crate_model_iot_site_wise_action(
&mut object_122,
var_121,
)?;
object_122.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_notification_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NotificationAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_123) = &input.action {
#[allow(unused_mut)]
let mut object_124 = object.key("action").start_object();
crate::json_ser::serialize_structure_crate_model_notification_target_actions(
&mut object_124,
var_123,
)?;
object_124.finish();
}
if let Some(var_125) = &input.sms_configurations {
let mut array_126 = object.key("smsConfigurations").start_array();
for item_127 in var_125 {
{
#[allow(unused_mut)]
let mut object_128 = array_126.value().start_object();
crate::json_ser::serialize_structure_crate_model_sms_configuration(
&mut object_128,
item_127,
)?;
object_128.finish();
}
}
array_126.finish();
}
if let Some(var_129) = &input.email_configurations {
let mut array_130 = object.key("emailConfigurations").start_array();
for item_131 in var_129 {
{
#[allow(unused_mut)]
let mut object_132 = array_130.value().start_object();
crate::json_ser::serialize_structure_crate_model_email_configuration(
&mut object_132,
item_131,
)?;
object_132.finish();
}
}
array_130.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_simple_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SimpleRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_133) = &input.input_property {
object.key("inputProperty").string(var_133.as_str());
}
if let Some(var_134) = &input.comparison_operator {
object.key("comparisonOperator").string(var_134.as_str());
}
if let Some(var_135) = &input.threshold {
object.key("threshold").string(var_135.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_state(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::State,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_136) = &input.state_name {
object.key("stateName").string(var_136.as_str());
}
if let Some(var_137) = &input.on_input {
#[allow(unused_mut)]
let mut object_138 = object.key("onInput").start_object();
crate::json_ser::serialize_structure_crate_model_on_input_lifecycle(
&mut object_138,
var_137,
)?;
object_138.finish();
}
if let Some(var_139) = &input.on_enter {
#[allow(unused_mut)]
let mut object_140 = object.key("onEnter").start_object();
crate::json_ser::serialize_structure_crate_model_on_enter_lifecycle(
&mut object_140,
var_139,
)?;
object_140.finish();
}
if let Some(var_141) = &input.on_exit {
#[allow(unused_mut)]
let mut object_142 = object.key("onExit").start_object();
crate::json_ser::serialize_structure_crate_model_on_exit_lifecycle(
&mut object_142,
var_141,
)?;
object_142.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_attribute(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Attribute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_143) = &input.json_path {
object.key("jsonPath").string(var_143.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_iot_events_input_identifier(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IotEventsInputIdentifier,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_144) = &input.input_name {
object.key("inputName").string(var_144.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_iot_site_wise_input_identifier(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IotSiteWiseInputIdentifier,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_145) = &input.iot_site_wise_asset_model_property_identifier {
#[allow(unused_mut)]
let mut object_146 = object
.key("iotSiteWiseAssetModelPropertyIdentifier")
.start_object();
crate::json_ser::serialize_structure_crate_model_iot_site_wise_asset_model_property_identifier(&mut object_146, var_145)?;
object_146.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_detector_debug_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DetectorDebugOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_147) = &input.detector_model_name {
object.key("detectorModelName").string(var_147.as_str());
}
if let Some(var_148) = &input.key_value {
object.key("keyValue").string(var_148.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sns_topic_publish_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SnsTopicPublishAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_149) = &input.target_arn {
object.key("targetArn").string(var_149.as_str());
}
if let Some(var_150) = &input.payload {
#[allow(unused_mut)]
let mut object_151 = object.key("payload").start_object();
crate::json_ser::serialize_structure_crate_model_payload(&mut object_151, var_150)?;
object_151.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_iot_topic_publish_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IotTopicPublishAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_152) = &input.mqtt_topic {
object.key("mqttTopic").string(var_152.as_str());
}
if let Some(var_153) = &input.payload {
#[allow(unused_mut)]
let mut object_154 = object.key("payload").start_object();
crate::json_ser::serialize_structure_crate_model_payload(&mut object_154, var_153)?;
object_154.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_lambda_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LambdaAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_155) = &input.function_arn {
object.key("functionArn").string(var_155.as_str());
}
if let Some(var_156) = &input.payload {
#[allow(unused_mut)]
let mut object_157 = object.key("payload").start_object();
crate::json_ser::serialize_structure_crate_model_payload(&mut object_157, var_156)?;
object_157.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_iot_events_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IotEventsAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_158) = &input.input_name {
object.key("inputName").string(var_158.as_str());
}
if let Some(var_159) = &input.payload {
#[allow(unused_mut)]
let mut object_160 = object.key("payload").start_object();
crate::json_ser::serialize_structure_crate_model_payload(&mut object_160, var_159)?;
object_160.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sqs_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SqsAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_161) = &input.queue_url {
object.key("queueUrl").string(var_161.as_str());
}
if let Some(var_162) = &input.use_base64 {
object.key("useBase64").boolean(*var_162);
}
if let Some(var_163) = &input.payload {
#[allow(unused_mut)]
let mut object_164 = object.key("payload").start_object();
crate::json_ser::serialize_structure_crate_model_payload(&mut object_164, var_163)?;
object_164.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_firehose_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FirehoseAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_165) = &input.delivery_stream_name {
object.key("deliveryStreamName").string(var_165.as_str());
}
if let Some(var_166) = &input.separator {
object.key("separator").string(var_166.as_str());
}
if let Some(var_167) = &input.payload {
#[allow(unused_mut)]
let mut object_168 = object.key("payload").start_object();
crate::json_ser::serialize_structure_crate_model_payload(&mut object_168, var_167)?;
object_168.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_dynamo_db_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DynamoDbAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_169) = &input.hash_key_type {
object.key("hashKeyType").string(var_169.as_str());
}
if let Some(var_170) = &input.hash_key_field {
object.key("hashKeyField").string(var_170.as_str());
}
if let Some(var_171) = &input.hash_key_value {
object.key("hashKeyValue").string(var_171.as_str());
}
if let Some(var_172) = &input.range_key_type {
object.key("rangeKeyType").string(var_172.as_str());
}
if let Some(var_173) = &input.range_key_field {
object.key("rangeKeyField").string(var_173.as_str());
}
if let Some(var_174) = &input.range_key_value {
object.key("rangeKeyValue").string(var_174.as_str());
}
if let Some(var_175) = &input.operation {
object.key("operation").string(var_175.as_str());
}
if let Some(var_176) = &input.payload_field {
object.key("payloadField").string(var_176.as_str());
}
if let Some(var_177) = &input.table_name {
object.key("tableName").string(var_177.as_str());
}
if let Some(var_178) = &input.payload {
#[allow(unused_mut)]
let mut object_179 = object.key("payload").start_object();
crate::json_ser::serialize_structure_crate_model_payload(&mut object_179, var_178)?;
object_179.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_dynamo_d_bv2_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DynamoDBv2Action,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_180) = &input.table_name {
object.key("tableName").string(var_180.as_str());
}
if let Some(var_181) = &input.payload {
#[allow(unused_mut)]
let mut object_182 = object.key("payload").start_object();
crate::json_ser::serialize_structure_crate_model_payload(&mut object_182, var_181)?;
object_182.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_iot_site_wise_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IotSiteWiseAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_183) = &input.entry_id {
object.key("entryId").string(var_183.as_str());
}
if let Some(var_184) = &input.asset_id {
object.key("assetId").string(var_184.as_str());
}
if let Some(var_185) = &input.property_id {
object.key("propertyId").string(var_185.as_str());
}
if let Some(var_186) = &input.property_alias {
object.key("propertyAlias").string(var_186.as_str());
}
if let Some(var_187) = &input.property_value {
#[allow(unused_mut)]
let mut object_188 = object.key("propertyValue").start_object();
crate::json_ser::serialize_structure_crate_model_asset_property_value(
&mut object_188,
var_187,
)?;
object_188.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_notification_target_actions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NotificationTargetActions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_189) = &input.lambda_action {
#[allow(unused_mut)]
let mut object_190 = object.key("lambdaAction").start_object();
crate::json_ser::serialize_structure_crate_model_lambda_action(&mut object_190, var_189)?;
object_190.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sms_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SmsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_191) = &input.sender_id {
object.key("senderId").string(var_191.as_str());
}
if let Some(var_192) = &input.additional_message {
object.key("additionalMessage").string(var_192.as_str());
}
if let Some(var_193) = &input.recipients {
let mut array_194 = object.key("recipients").start_array();
for item_195 in var_193 {
{
#[allow(unused_mut)]
let mut object_196 = array_194.value().start_object();
crate::json_ser::serialize_structure_crate_model_recipient_detail(
&mut object_196,
item_195,
)?;
object_196.finish();
}
}
array_194.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_email_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EmailConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_197) = &input.from {
object.key("from").string(var_197.as_str());
}
if let Some(var_198) = &input.content {
#[allow(unused_mut)]
let mut object_199 = object.key("content").start_object();
crate::json_ser::serialize_structure_crate_model_email_content(&mut object_199, var_198)?;
object_199.finish();
}
if let Some(var_200) = &input.recipients {
#[allow(unused_mut)]
let mut object_201 = object.key("recipients").start_object();
crate::json_ser::serialize_structure_crate_model_email_recipients(
&mut object_201,
var_200,
)?;
object_201.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_on_input_lifecycle(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OnInputLifecycle,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_202) = &input.events {
let mut array_203 = object.key("events").start_array();
for item_204 in var_202 {
{
#[allow(unused_mut)]
let mut object_205 = array_203.value().start_object();
crate::json_ser::serialize_structure_crate_model_event(&mut object_205, item_204)?;
object_205.finish();
}
}
array_203.finish();
}
if let Some(var_206) = &input.transition_events {
let mut array_207 = object.key("transitionEvents").start_array();
for item_208 in var_206 {
{
#[allow(unused_mut)]
let mut object_209 = array_207.value().start_object();
crate::json_ser::serialize_structure_crate_model_transition_event(
&mut object_209,
item_208,
)?;
object_209.finish();
}
}
array_207.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_on_enter_lifecycle(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OnEnterLifecycle,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_210) = &input.events {
let mut array_211 = object.key("events").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_event(&mut object_213, item_212)?;
object_213.finish();
}
}
array_211.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_on_exit_lifecycle(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OnExitLifecycle,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_214) = &input.events {
let mut array_215 = object.key("events").start_array();
for item_216 in var_214 {
{
#[allow(unused_mut)]
let mut object_217 = array_215.value().start_object();
crate::json_ser::serialize_structure_crate_model_event(&mut object_217, item_216)?;
object_217.finish();
}
}
array_215.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_iot_site_wise_asset_model_property_identifier(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IotSiteWiseAssetModelPropertyIdentifier,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_218) = &input.asset_model_id {
object.key("assetModelId").string(var_218.as_str());
}
if let Some(var_219) = &input.property_id {
object.key("propertyId").string(var_219.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_payload(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Payload,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_220) = &input.content_expression {
object.key("contentExpression").string(var_220.as_str());
}
if let Some(var_221) = &input.r#type {
object.key("type").string(var_221.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_asset_property_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AssetPropertyValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_222) = &input.value {
#[allow(unused_mut)]
let mut object_223 = object.key("value").start_object();
crate::json_ser::serialize_structure_crate_model_asset_property_variant(
&mut object_223,
var_222,
)?;
object_223.finish();
}
if let Some(var_224) = &input.timestamp {
#[allow(unused_mut)]
let mut object_225 = object.key("timestamp").start_object();
crate::json_ser::serialize_structure_crate_model_asset_property_timestamp(
&mut object_225,
var_224,
)?;
object_225.finish();
}
if let Some(var_226) = &input.quality {
object.key("quality").string(var_226.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_recipient_detail(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RecipientDetail,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_227) = &input.sso_identity {
#[allow(unused_mut)]
let mut object_228 = object.key("ssoIdentity").start_object();
crate::json_ser::serialize_structure_crate_model_sso_identity(&mut object_228, var_227)?;
object_228.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_email_content(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EmailContent,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_229) = &input.subject {
object.key("subject").string(var_229.as_str());
}
if let Some(var_230) = &input.additional_message {
object.key("additionalMessage").string(var_230.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_email_recipients(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EmailRecipients,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_231) = &input.to {
let mut array_232 = object.key("to").start_array();
for item_233 in var_231 {
{
#[allow(unused_mut)]
let mut object_234 = array_232.value().start_object();
crate::json_ser::serialize_structure_crate_model_recipient_detail(
&mut object_234,
item_233,
)?;
object_234.finish();
}
}
array_232.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_event(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Event,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_235) = &input.event_name {
object.key("eventName").string(var_235.as_str());
}
if let Some(var_236) = &input.condition {
object.key("condition").string(var_236.as_str());
}
if let Some(var_237) = &input.actions {
let mut array_238 = object.key("actions").start_array();
for item_239 in var_237 {
{
#[allow(unused_mut)]
let mut object_240 = array_238.value().start_object();
crate::json_ser::serialize_structure_crate_model_action(&mut object_240, item_239)?;
object_240.finish();
}
}
array_238.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_transition_event(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TransitionEvent,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_241) = &input.event_name {
object.key("eventName").string(var_241.as_str());
}
if let Some(var_242) = &input.condition {
object.key("condition").string(var_242.as_str());
}
if let Some(var_243) = &input.actions {
let mut array_244 = object.key("actions").start_array();
for item_245 in var_243 {
{
#[allow(unused_mut)]
let mut object_246 = array_244.value().start_object();
crate::json_ser::serialize_structure_crate_model_action(&mut object_246, item_245)?;
object_246.finish();
}
}
array_244.finish();
}
if let Some(var_247) = &input.next_state {
object.key("nextState").string(var_247.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_asset_property_variant(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AssetPropertyVariant,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_248) = &input.string_value {
object.key("stringValue").string(var_248.as_str());
}
if let Some(var_249) = &input.integer_value {
object.key("integerValue").string(var_249.as_str());
}
if let Some(var_250) = &input.double_value {
object.key("doubleValue").string(var_250.as_str());
}
if let Some(var_251) = &input.boolean_value {
object.key("booleanValue").string(var_251.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_asset_property_timestamp(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AssetPropertyTimestamp,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_252) = &input.time_in_seconds {
object.key("timeInSeconds").string(var_252.as_str());
}
if let Some(var_253) = &input.offset_in_nanos {
object.key("offsetInNanos").string(var_253.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sso_identity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SsoIdentity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_254) = &input.identity_store_id {
object.key("identityStoreId").string(var_254.as_str());
}
if let Some(var_255) = &input.user_id {
object.key("userId").string(var_255.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Action,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_256) = &input.set_variable {
#[allow(unused_mut)]
let mut object_257 = object.key("setVariable").start_object();
crate::json_ser::serialize_structure_crate_model_set_variable_action(
&mut object_257,
var_256,
)?;
object_257.finish();
}
if let Some(var_258) = &input.sns {
#[allow(unused_mut)]
let mut object_259 = object.key("sns").start_object();
crate::json_ser::serialize_structure_crate_model_sns_topic_publish_action(
&mut object_259,
var_258,
)?;
object_259.finish();
}
if let Some(var_260) = &input.iot_topic_publish {
#[allow(unused_mut)]
let mut object_261 = object.key("iotTopicPublish").start_object();
crate::json_ser::serialize_structure_crate_model_iot_topic_publish_action(
&mut object_261,
var_260,
)?;
object_261.finish();
}
if let Some(var_262) = &input.set_timer {
#[allow(unused_mut)]
let mut object_263 = object.key("setTimer").start_object();
crate::json_ser::serialize_structure_crate_model_set_timer_action(
&mut object_263,
var_262,
)?;
object_263.finish();
}
if let Some(var_264) = &input.clear_timer {
#[allow(unused_mut)]
let mut object_265 = object.key("clearTimer").start_object();
crate::json_ser::serialize_structure_crate_model_clear_timer_action(
&mut object_265,
var_264,
)?;
object_265.finish();
}
if let Some(var_266) = &input.reset_timer {
#[allow(unused_mut)]
let mut object_267 = object.key("resetTimer").start_object();
crate::json_ser::serialize_structure_crate_model_reset_timer_action(
&mut object_267,
var_266,
)?;
object_267.finish();
}
if let Some(var_268) = &input.lambda {
#[allow(unused_mut)]
let mut object_269 = object.key("lambda").start_object();
crate::json_ser::serialize_structure_crate_model_lambda_action(&mut object_269, var_268)?;
object_269.finish();
}
if let Some(var_270) = &input.iot_events {
#[allow(unused_mut)]
let mut object_271 = object.key("iotEvents").start_object();
crate::json_ser::serialize_structure_crate_model_iot_events_action(
&mut object_271,
var_270,
)?;
object_271.finish();
}
if let Some(var_272) = &input.sqs {
#[allow(unused_mut)]
let mut object_273 = object.key("sqs").start_object();
crate::json_ser::serialize_structure_crate_model_sqs_action(&mut object_273, var_272)?;
object_273.finish();
}
if let Some(var_274) = &input.firehose {
#[allow(unused_mut)]
let mut object_275 = object.key("firehose").start_object();
crate::json_ser::serialize_structure_crate_model_firehose_action(&mut object_275, var_274)?;
object_275.finish();
}
if let Some(var_276) = &input.dynamo_db {
#[allow(unused_mut)]
let mut object_277 = object.key("dynamoDB").start_object();
crate::json_ser::serialize_structure_crate_model_dynamo_db_action(
&mut object_277,
var_276,
)?;
object_277.finish();
}
if let Some(var_278) = &input.dynamo_d_bv2 {
#[allow(unused_mut)]
let mut object_279 = object.key("dynamoDBv2").start_object();
crate::json_ser::serialize_structure_crate_model_dynamo_d_bv2_action(
&mut object_279,
var_278,
)?;
object_279.finish();
}
if let Some(var_280) = &input.iot_site_wise {
#[allow(unused_mut)]
let mut object_281 = object.key("iotSiteWise").start_object();
crate::json_ser::serialize_structure_crate_model_iot_site_wise_action(
&mut object_281,
var_280,
)?;
object_281.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_set_variable_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SetVariableAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_282) = &input.variable_name {
object.key("variableName").string(var_282.as_str());
}
if let Some(var_283) = &input.value {
object.key("value").string(var_283.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_set_timer_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SetTimerAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_284) = &input.timer_name {
object.key("timerName").string(var_284.as_str());
}
if let Some(var_285) = &input.seconds {
object.key("seconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_285).into()),
);
}
if let Some(var_286) = &input.duration_expression {
object.key("durationExpression").string(var_286.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_clear_timer_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ClearTimerAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_287) = &input.timer_name {
object.key("timerName").string(var_287.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_reset_timer_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResetTimerAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_288) = &input.timer_name {
object.key("timerName").string(var_288.as_str());
}
Ok(())
}