json_ser.rs

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub fn serialize_structure_batch_put_message_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::BatchPutMessageInput,
) {
    if let Some(var_1) = &input.channel_name {
        object.key("channelName").string(var_1);
    }
    if let Some(var_2) = &input.messages {
        let mut array_3 = object.key("messages").start_array();
        for item_4 in var_2 {
            {
                let mut object_5 = array_3.value().start_object();
                crate::json_ser::serialize_structure_message(&mut object_5, item_4);
                object_5.finish();
            }
        }
        array_3.finish();
    }
}

pub fn serialize_structure_create_channel_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateChannelInput,
) {
    if let Some(var_6) = &input.channel_name {
        object.key("channelName").string(var_6);
    }
    if let Some(var_7) = &input.channel_storage {
        let mut object_8 = object.key("channelStorage").start_object();
        crate::json_ser::serialize_structure_channel_storage(&mut object_8, var_7);
        object_8.finish();
    }
    if let Some(var_9) = &input.retention_period {
        let mut object_10 = object.key("retentionPeriod").start_object();
        crate::json_ser::serialize_structure_retention_period(&mut object_10, var_9);
        object_10.finish();
    }
    if let Some(var_11) = &input.tags {
        let mut array_12 = object.key("tags").start_array();
        for item_13 in var_11 {
            {
                let mut object_14 = array_12.value().start_object();
                crate::json_ser::serialize_structure_tag(&mut object_14, item_13);
                object_14.finish();
            }
        }
        array_12.finish();
    }
}

pub fn serialize_structure_create_dataset_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateDatasetInput,
) {
    if let Some(var_15) = &input.actions {
        let mut array_16 = object.key("actions").start_array();
        for item_17 in var_15 {
            {
                let mut object_18 = array_16.value().start_object();
                crate::json_ser::serialize_structure_dataset_action(&mut object_18, item_17);
                object_18.finish();
            }
        }
        array_16.finish();
    }
    if let Some(var_19) = &input.content_delivery_rules {
        let mut array_20 = object.key("contentDeliveryRules").start_array();
        for item_21 in var_19 {
            {
                let mut object_22 = array_20.value().start_object();
                crate::json_ser::serialize_structure_dataset_content_delivery_rule(
                    &mut object_22,
                    item_21,
                );
                object_22.finish();
            }
        }
        array_20.finish();
    }
    if let Some(var_23) = &input.dataset_name {
        object.key("datasetName").string(var_23);
    }
    if let Some(var_24) = &input.late_data_rules {
        let mut array_25 = object.key("lateDataRules").start_array();
        for item_26 in var_24 {
            {
                let mut object_27 = array_25.value().start_object();
                crate::json_ser::serialize_structure_late_data_rule(&mut object_27, item_26);
                object_27.finish();
            }
        }
        array_25.finish();
    }
    if let Some(var_28) = &input.retention_period {
        let mut object_29 = object.key("retentionPeriod").start_object();
        crate::json_ser::serialize_structure_retention_period(&mut object_29, var_28);
        object_29.finish();
    }
    if let Some(var_30) = &input.tags {
        let mut array_31 = object.key("tags").start_array();
        for item_32 in var_30 {
            {
                let mut object_33 = array_31.value().start_object();
                crate::json_ser::serialize_structure_tag(&mut object_33, item_32);
                object_33.finish();
            }
        }
        array_31.finish();
    }
    if let Some(var_34) = &input.triggers {
        let mut array_35 = object.key("triggers").start_array();
        for item_36 in var_34 {
            {
                let mut object_37 = array_35.value().start_object();
                crate::json_ser::serialize_structure_dataset_trigger(&mut object_37, item_36);
                object_37.finish();
            }
        }
        array_35.finish();
    }
    if let Some(var_38) = &input.versioning_configuration {
        let mut object_39 = object.key("versioningConfiguration").start_object();
        crate::json_ser::serialize_structure_versioning_configuration(&mut object_39, var_38);
        object_39.finish();
    }
}

pub fn serialize_structure_create_dataset_content_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateDatasetContentInput,
) {
    if let Some(var_40) = &input.version_id {
        object.key("versionId").string(var_40);
    }
}

pub fn serialize_structure_create_datastore_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateDatastoreInput,
) {
    if let Some(var_41) = &input.datastore_name {
        object.key("datastoreName").string(var_41);
    }
    if let Some(var_42) = &input.datastore_partitions {
        let mut object_43 = object.key("datastorePartitions").start_object();
        crate::json_ser::serialize_structure_datastore_partitions(&mut object_43, var_42);
        object_43.finish();
    }
    if let Some(var_44) = &input.datastore_storage {
        let mut object_45 = object.key("datastoreStorage").start_object();
        crate::json_ser::serialize_union_datastore_storage(&mut object_45, var_44);
        object_45.finish();
    }
    if let Some(var_46) = &input.file_format_configuration {
        let mut object_47 = object.key("fileFormatConfiguration").start_object();
        crate::json_ser::serialize_structure_file_format_configuration(&mut object_47, var_46);
        object_47.finish();
    }
    if let Some(var_48) = &input.retention_period {
        let mut object_49 = object.key("retentionPeriod").start_object();
        crate::json_ser::serialize_structure_retention_period(&mut object_49, var_48);
        object_49.finish();
    }
    if let Some(var_50) = &input.tags {
        let mut array_51 = object.key("tags").start_array();
        for item_52 in var_50 {
            {
                let mut object_53 = array_51.value().start_object();
                crate::json_ser::serialize_structure_tag(&mut object_53, item_52);
                object_53.finish();
            }
        }
        array_51.finish();
    }
}

pub fn serialize_structure_create_pipeline_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreatePipelineInput,
) {
    if let Some(var_54) = &input.pipeline_activities {
        let mut array_55 = object.key("pipelineActivities").start_array();
        for item_56 in var_54 {
            {
                let mut object_57 = array_55.value().start_object();
                crate::json_ser::serialize_structure_pipeline_activity(&mut object_57, item_56);
                object_57.finish();
            }
        }
        array_55.finish();
    }
    if let Some(var_58) = &input.pipeline_name {
        object.key("pipelineName").string(var_58);
    }
    if let Some(var_59) = &input.tags {
        let mut array_60 = object.key("tags").start_array();
        for item_61 in var_59 {
            {
                let mut object_62 = array_60.value().start_object();
                crate::json_ser::serialize_structure_tag(&mut object_62, item_61);
                object_62.finish();
            }
        }
        array_60.finish();
    }
}

pub fn serialize_structure_put_logging_options_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutLoggingOptionsInput,
) {
    if let Some(var_63) = &input.logging_options {
        let mut object_64 = object.key("loggingOptions").start_object();
        crate::json_ser::serialize_structure_logging_options(&mut object_64, var_63);
        object_64.finish();
    }
}

pub fn serialize_structure_run_pipeline_activity_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::RunPipelineActivityInput,
) {
    if let Some(var_65) = &input.payloads {
        let mut array_66 = object.key("payloads").start_array();
        for item_67 in var_65 {
            {
                array_66
                    .value()
                    .string_unchecked(&smithy_types::base64::encode(item_67));
            }
        }
        array_66.finish();
    }
    if let Some(var_68) = &input.pipeline_activity {
        let mut object_69 = object.key("pipelineActivity").start_object();
        crate::json_ser::serialize_structure_pipeline_activity(&mut object_69, var_68);
        object_69.finish();
    }
}

pub fn serialize_structure_start_pipeline_reprocessing_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::StartPipelineReprocessingInput,
) {
    if let Some(var_70) = &input.channel_messages {
        let mut object_71 = object.key("channelMessages").start_object();
        crate::json_ser::serialize_structure_channel_messages(&mut object_71, var_70);
        object_71.finish();
    }
    if let Some(var_72) = &input.end_time {
        object
            .key("endTime")
            .instant(var_72, smithy_types::instant::Format::EpochSeconds);
    }
    if let Some(var_73) = &input.start_time {
        object
            .key("startTime")
            .instant(var_73, smithy_types::instant::Format::EpochSeconds);
    }
}

pub fn serialize_structure_tag_resource_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::TagResourceInput,
) {
    if let Some(var_74) = &input.tags {
        let mut array_75 = object.key("tags").start_array();
        for item_76 in var_74 {
            {
                let mut object_77 = array_75.value().start_object();
                crate::json_ser::serialize_structure_tag(&mut object_77, item_76);
                object_77.finish();
            }
        }
        array_75.finish();
    }
}

pub fn serialize_structure_update_channel_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateChannelInput,
) {
    if let Some(var_78) = &input.channel_storage {
        let mut object_79 = object.key("channelStorage").start_object();
        crate::json_ser::serialize_structure_channel_storage(&mut object_79, var_78);
        object_79.finish();
    }
    if let Some(var_80) = &input.retention_period {
        let mut object_81 = object.key("retentionPeriod").start_object();
        crate::json_ser::serialize_structure_retention_period(&mut object_81, var_80);
        object_81.finish();
    }
}

pub fn serialize_structure_update_dataset_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateDatasetInput,
) {
    if let Some(var_82) = &input.actions {
        let mut array_83 = object.key("actions").start_array();
        for item_84 in var_82 {
            {
                let mut object_85 = array_83.value().start_object();
                crate::json_ser::serialize_structure_dataset_action(&mut object_85, item_84);
                object_85.finish();
            }
        }
        array_83.finish();
    }
    if let Some(var_86) = &input.content_delivery_rules {
        let mut array_87 = object.key("contentDeliveryRules").start_array();
        for item_88 in var_86 {
            {
                let mut object_89 = array_87.value().start_object();
                crate::json_ser::serialize_structure_dataset_content_delivery_rule(
                    &mut object_89,
                    item_88,
                );
                object_89.finish();
            }
        }
        array_87.finish();
    }
    if let Some(var_90) = &input.late_data_rules {
        let mut array_91 = object.key("lateDataRules").start_array();
        for item_92 in var_90 {
            {
                let mut object_93 = array_91.value().start_object();
                crate::json_ser::serialize_structure_late_data_rule(&mut object_93, item_92);
                object_93.finish();
            }
        }
        array_91.finish();
    }
    if let Some(var_94) = &input.retention_period {
        let mut object_95 = object.key("retentionPeriod").start_object();
        crate::json_ser::serialize_structure_retention_period(&mut object_95, var_94);
        object_95.finish();
    }
    if let Some(var_96) = &input.triggers {
        let mut array_97 = object.key("triggers").start_array();
        for item_98 in var_96 {
            {
                let mut object_99 = array_97.value().start_object();
                crate::json_ser::serialize_structure_dataset_trigger(&mut object_99, item_98);
                object_99.finish();
            }
        }
        array_97.finish();
    }
    if let Some(var_100) = &input.versioning_configuration {
        let mut object_101 = object.key("versioningConfiguration").start_object();
        crate::json_ser::serialize_structure_versioning_configuration(&mut object_101, var_100);
        object_101.finish();
    }
}

pub fn serialize_structure_update_datastore_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateDatastoreInput,
) {
    if let Some(var_102) = &input.datastore_storage {
        let mut object_103 = object.key("datastoreStorage").start_object();
        crate::json_ser::serialize_union_datastore_storage(&mut object_103, var_102);
        object_103.finish();
    }
    if let Some(var_104) = &input.file_format_configuration {
        let mut object_105 = object.key("fileFormatConfiguration").start_object();
        crate::json_ser::serialize_structure_file_format_configuration(&mut object_105, var_104);
        object_105.finish();
    }
    if let Some(var_106) = &input.retention_period {
        let mut object_107 = object.key("retentionPeriod").start_object();
        crate::json_ser::serialize_structure_retention_period(&mut object_107, var_106);
        object_107.finish();
    }
}

pub fn serialize_structure_update_pipeline_input(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdatePipelineInput,
) {
    if let Some(var_108) = &input.pipeline_activities {
        let mut array_109 = object.key("pipelineActivities").start_array();
        for item_110 in var_108 {
            {
                let mut object_111 = array_109.value().start_object();
                crate::json_ser::serialize_structure_pipeline_activity(&mut object_111, item_110);
                object_111.finish();
            }
        }
        array_109.finish();
    }
}

pub fn serialize_structure_message(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Message,
) {
    if let Some(var_112) = &input.message_id {
        object.key("messageId").string(var_112);
    }
    if let Some(var_113) = &input.payload {
        object
            .key("payload")
            .string_unchecked(&smithy_types::base64::encode(var_113));
    }
}

pub fn serialize_structure_channel_storage(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ChannelStorage,
) {
    if let Some(var_114) = &input.service_managed_s3 {
        let mut object_115 = object.key("serviceManagedS3").start_object();
        crate::json_ser::serialize_structure_service_managed_channel_s3_storage(
            &mut object_115,
            var_114,
        );
        object_115.finish();
    }
    if let Some(var_116) = &input.customer_managed_s3 {
        let mut object_117 = object.key("customerManagedS3").start_object();
        crate::json_ser::serialize_structure_customer_managed_channel_s3_storage(
            &mut object_117,
            var_116,
        );
        object_117.finish();
    }
}

pub fn serialize_structure_retention_period(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::RetentionPeriod,
) {
    if input.unlimited {
        object.key("unlimited").boolean(input.unlimited);
    }
    if let Some(var_118) = &input.number_of_days {
        object.key("numberOfDays").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_118).into()),
        );
    }
}

pub fn serialize_structure_tag(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Tag,
) {
    if let Some(var_119) = &input.key {
        object.key("key").string(var_119);
    }
    if let Some(var_120) = &input.value {
        object.key("value").string(var_120);
    }
}

pub fn serialize_structure_dataset_action(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DatasetAction,
) {
    if let Some(var_121) = &input.action_name {
        object.key("actionName").string(var_121);
    }
    if let Some(var_122) = &input.query_action {
        let mut object_123 = object.key("queryAction").start_object();
        crate::json_ser::serialize_structure_sql_query_dataset_action(&mut object_123, var_122);
        object_123.finish();
    }
    if let Some(var_124) = &input.container_action {
        let mut object_125 = object.key("containerAction").start_object();
        crate::json_ser::serialize_structure_container_dataset_action(&mut object_125, var_124);
        object_125.finish();
    }
}

pub fn serialize_structure_dataset_content_delivery_rule(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DatasetContentDeliveryRule,
) {
    if let Some(var_126) = &input.entry_name {
        object.key("entryName").string(var_126);
    }
    if let Some(var_127) = &input.destination {
        let mut object_128 = object.key("destination").start_object();
        crate::json_ser::serialize_structure_dataset_content_delivery_destination(
            &mut object_128,
            var_127,
        );
        object_128.finish();
    }
}

pub fn serialize_structure_late_data_rule(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::LateDataRule,
) {
    if let Some(var_129) = &input.rule_name {
        object.key("ruleName").string(var_129);
    }
    if let Some(var_130) = &input.rule_configuration {
        let mut object_131 = object.key("ruleConfiguration").start_object();
        crate::json_ser::serialize_structure_late_data_rule_configuration(&mut object_131, var_130);
        object_131.finish();
    }
}

pub fn serialize_structure_dataset_trigger(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DatasetTrigger,
) {
    if let Some(var_132) = &input.schedule {
        let mut object_133 = object.key("schedule").start_object();
        crate::json_ser::serialize_structure_schedule(&mut object_133, var_132);
        object_133.finish();
    }
    if let Some(var_134) = &input.dataset {
        let mut object_135 = object.key("dataset").start_object();
        crate::json_ser::serialize_structure_triggering_dataset(&mut object_135, var_134);
        object_135.finish();
    }
}

pub fn serialize_structure_versioning_configuration(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VersioningConfiguration,
) {
    if input.unlimited {
        object.key("unlimited").boolean(input.unlimited);
    }
    if let Some(var_136) = &input.max_versions {
        object.key("maxVersions").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_136).into()),
        );
    }
}

pub fn serialize_structure_datastore_partitions(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DatastorePartitions,
) {
    if let Some(var_137) = &input.partitions {
        let mut array_138 = object.key("partitions").start_array();
        for item_139 in var_137 {
            {
                let mut object_140 = array_138.value().start_object();
                crate::json_ser::serialize_structure_datastore_partition(&mut object_140, item_139);
                object_140.finish();
            }
        }
        array_138.finish();
    }
}

pub fn serialize_union_datastore_storage(
    object_45: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DatastoreStorage,
) {
    match input {
        crate::model::DatastoreStorage::ServiceManagedS3(inner) => {
            let mut object_141 = object_45.key("serviceManagedS3").start_object();
            crate::json_ser::serialize_structure_service_managed_datastore_s3_storage(
                &mut object_141,
                inner,
            );
            object_141.finish();
        }
        crate::model::DatastoreStorage::CustomerManagedS3(inner) => {
            let mut object_142 = object_45.key("customerManagedS3").start_object();
            crate::json_ser::serialize_structure_customer_managed_datastore_s3_storage(
                &mut object_142,
                inner,
            );
            object_142.finish();
        }
        crate::model::DatastoreStorage::IotSiteWiseMultiLayerStorage(inner) => {
            let mut object_143 = object_45.key("iotSiteWiseMultiLayerStorage").start_object();
            crate::json_ser::serialize_structure_datastore_iot_site_wise_multi_layer_storage(
                &mut object_143,
                inner,
            );
            object_143.finish();
        }
    }
}

pub fn serialize_structure_file_format_configuration(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::FileFormatConfiguration,
) {
    if let Some(var_144) = &input.json_configuration {
        let mut object_145 = object.key("jsonConfiguration").start_object();
        crate::json_ser::serialize_structure_json_configuration(&mut object_145, var_144);
        object_145.finish();
    }
    if let Some(var_146) = &input.parquet_configuration {
        let mut object_147 = object.key("parquetConfiguration").start_object();
        crate::json_ser::serialize_structure_parquet_configuration(&mut object_147, var_146);
        object_147.finish();
    }
}

pub fn serialize_structure_pipeline_activity(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::PipelineActivity,
) {
    if let Some(var_148) = &input.channel {
        let mut object_149 = object.key("channel").start_object();
        crate::json_ser::serialize_structure_channel_activity(&mut object_149, var_148);
        object_149.finish();
    }
    if let Some(var_150) = &input.lambda {
        let mut object_151 = object.key("lambda").start_object();
        crate::json_ser::serialize_structure_lambda_activity(&mut object_151, var_150);
        object_151.finish();
    }
    if let Some(var_152) = &input.datastore {
        let mut object_153 = object.key("datastore").start_object();
        crate::json_ser::serialize_structure_datastore_activity(&mut object_153, var_152);
        object_153.finish();
    }
    if let Some(var_154) = &input.add_attributes {
        let mut object_155 = object.key("addAttributes").start_object();
        crate::json_ser::serialize_structure_add_attributes_activity(&mut object_155, var_154);
        object_155.finish();
    }
    if let Some(var_156) = &input.remove_attributes {
        let mut object_157 = object.key("removeAttributes").start_object();
        crate::json_ser::serialize_structure_remove_attributes_activity(&mut object_157, var_156);
        object_157.finish();
    }
    if let Some(var_158) = &input.select_attributes {
        let mut object_159 = object.key("selectAttributes").start_object();
        crate::json_ser::serialize_structure_select_attributes_activity(&mut object_159, var_158);
        object_159.finish();
    }
    if let Some(var_160) = &input.filter {
        let mut object_161 = object.key("filter").start_object();
        crate::json_ser::serialize_structure_filter_activity(&mut object_161, var_160);
        object_161.finish();
    }
    if let Some(var_162) = &input.math {
        let mut object_163 = object.key("math").start_object();
        crate::json_ser::serialize_structure_math_activity(&mut object_163, var_162);
        object_163.finish();
    }
    if let Some(var_164) = &input.device_registry_enrich {
        let mut object_165 = object.key("deviceRegistryEnrich").start_object();
        crate::json_ser::serialize_structure_device_registry_enrich_activity(
            &mut object_165,
            var_164,
        );
        object_165.finish();
    }
    if let Some(var_166) = &input.device_shadow_enrich {
        let mut object_167 = object.key("deviceShadowEnrich").start_object();
        crate::json_ser::serialize_structure_device_shadow_enrich_activity(
            &mut object_167,
            var_166,
        );
        object_167.finish();
    }
}

pub fn serialize_structure_logging_options(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::LoggingOptions,
) {
    if let Some(var_168) = &input.role_arn {
        object.key("roleArn").string(var_168);
    }
    if let Some(var_169) = &input.level {
        object.key("level").string(var_169.as_str());
    }
    {
        object.key("enabled").boolean(input.enabled);
    }
}

pub fn serialize_structure_channel_messages(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ChannelMessages,
) {
    if let Some(var_170) = &input.s3_paths {
        let mut array_171 = object.key("s3Paths").start_array();
        for item_172 in var_170 {
            {
                array_171.value().string(item_172);
            }
        }
        array_171.finish();
    }
}

pub fn serialize_structure_service_managed_channel_s3_storage(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ServiceManagedChannelS3Storage,
) {
    let (_, _) = (object, input);
}

pub fn serialize_structure_customer_managed_channel_s3_storage(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CustomerManagedChannelS3Storage,
) {
    if let Some(var_173) = &input.bucket {
        object.key("bucket").string(var_173);
    }
    if let Some(var_174) = &input.key_prefix {
        object.key("keyPrefix").string(var_174);
    }
    if let Some(var_175) = &input.role_arn {
        object.key("roleArn").string(var_175);
    }
}

pub fn serialize_structure_sql_query_dataset_action(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SqlQueryDatasetAction,
) {
    if let Some(var_176) = &input.sql_query {
        object.key("sqlQuery").string(var_176);
    }
    if let Some(var_177) = &input.filters {
        let mut array_178 = object.key("filters").start_array();
        for item_179 in var_177 {
            {
                let mut object_180 = array_178.value().start_object();
                crate::json_ser::serialize_structure_query_filter(&mut object_180, item_179);
                object_180.finish();
            }
        }
        array_178.finish();
    }
}

pub fn serialize_structure_container_dataset_action(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ContainerDatasetAction,
) {
    if let Some(var_181) = &input.image {
        object.key("image").string(var_181);
    }
    if let Some(var_182) = &input.execution_role_arn {
        object.key("executionRoleArn").string(var_182);
    }
    if let Some(var_183) = &input.resource_configuration {
        let mut object_184 = object.key("resourceConfiguration").start_object();
        crate::json_ser::serialize_structure_resource_configuration(&mut object_184, var_183);
        object_184.finish();
    }
    if let Some(var_185) = &input.variables {
        let mut array_186 = object.key("variables").start_array();
        for item_187 in var_185 {
            {
                let mut object_188 = array_186.value().start_object();
                crate::json_ser::serialize_structure_variable(&mut object_188, item_187);
                object_188.finish();
            }
        }
        array_186.finish();
    }
}

pub fn serialize_structure_dataset_content_delivery_destination(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DatasetContentDeliveryDestination,
) {
    if let Some(var_189) = &input.iot_events_destination_configuration {
        let mut object_190 = object
            .key("iotEventsDestinationConfiguration")
            .start_object();
        crate::json_ser::serialize_structure_iot_events_destination_configuration(
            &mut object_190,
            var_189,
        );
        object_190.finish();
    }
    if let Some(var_191) = &input.s3_destination_configuration {
        let mut object_192 = object.key("s3DestinationConfiguration").start_object();
        crate::json_ser::serialize_structure_s3_destination_configuration(&mut object_192, var_191);
        object_192.finish();
    }
}

pub fn serialize_structure_late_data_rule_configuration(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::LateDataRuleConfiguration,
) {
    if let Some(var_193) = &input.delta_time_session_window_configuration {
        let mut object_194 = object
            .key("deltaTimeSessionWindowConfiguration")
            .start_object();
        crate::json_ser::serialize_structure_delta_time_session_window_configuration(
            &mut object_194,
            var_193,
        );
        object_194.finish();
    }
}

pub fn serialize_structure_schedule(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Schedule,
) {
    if let Some(var_195) = &input.expression {
        object.key("expression").string(var_195);
    }
}

pub fn serialize_structure_triggering_dataset(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TriggeringDataset,
) {
    if let Some(var_196) = &input.name {
        object.key("name").string(var_196);
    }
}

pub fn serialize_structure_datastore_partition(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DatastorePartition,
) {
    if let Some(var_197) = &input.attribute_partition {
        let mut object_198 = object.key("attributePartition").start_object();
        crate::json_ser::serialize_structure_partition(&mut object_198, var_197);
        object_198.finish();
    }
    if let Some(var_199) = &input.timestamp_partition {
        let mut object_200 = object.key("timestampPartition").start_object();
        crate::json_ser::serialize_structure_timestamp_partition(&mut object_200, var_199);
        object_200.finish();
    }
}

pub fn serialize_structure_service_managed_datastore_s3_storage(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ServiceManagedDatastoreS3Storage,
) {
    let (_, _) = (object, input);
}

pub fn serialize_structure_customer_managed_datastore_s3_storage(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::CustomerManagedDatastoreS3Storage,
) {
    if let Some(var_201) = &input.bucket {
        object.key("bucket").string(var_201);
    }
    if let Some(var_202) = &input.key_prefix {
        object.key("keyPrefix").string(var_202);
    }
    if let Some(var_203) = &input.role_arn {
        object.key("roleArn").string(var_203);
    }
}

pub fn serialize_structure_datastore_iot_site_wise_multi_layer_storage(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DatastoreIotSiteWiseMultiLayerStorage,
) {
    if let Some(var_204) = &input.customer_managed_s3_storage {
        let mut object_205 = object.key("customerManagedS3Storage").start_object();
        crate::json_ser::serialize_structure_iot_site_wise_customer_managed_datastore_s3_storage(
            &mut object_205,
            var_204,
        );
        object_205.finish();
    }
}

pub fn serialize_structure_json_configuration(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::JsonConfiguration,
) {
    let (_, _) = (object, input);
}

pub fn serialize_structure_parquet_configuration(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ParquetConfiguration,
) {
    if let Some(var_206) = &input.schema_definition {
        let mut object_207 = object.key("schemaDefinition").start_object();
        crate::json_ser::serialize_structure_schema_definition(&mut object_207, var_206);
        object_207.finish();
    }
}

pub fn serialize_structure_channel_activity(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ChannelActivity,
) {
    if let Some(var_208) = &input.name {
        object.key("name").string(var_208);
    }
    if let Some(var_209) = &input.channel_name {
        object.key("channelName").string(var_209);
    }
    if let Some(var_210) = &input.next {
        object.key("next").string(var_210);
    }
}

pub fn serialize_structure_lambda_activity(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::LambdaActivity,
) {
    if let Some(var_211) = &input.name {
        object.key("name").string(var_211);
    }
    if let Some(var_212) = &input.lambda_name {
        object.key("lambdaName").string(var_212);
    }
    if let Some(var_213) = &input.batch_size {
        object.key("batchSize").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_213).into()),
        );
    }
    if let Some(var_214) = &input.next {
        object.key("next").string(var_214);
    }
}

pub fn serialize_structure_datastore_activity(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DatastoreActivity,
) {
    if let Some(var_215) = &input.name {
        object.key("name").string(var_215);
    }
    if let Some(var_216) = &input.datastore_name {
        object.key("datastoreName").string(var_216);
    }
}

pub fn serialize_structure_add_attributes_activity(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AddAttributesActivity,
) {
    if let Some(var_217) = &input.name {
        object.key("name").string(var_217);
    }
    if let Some(var_218) = &input.attributes {
        let mut object_219 = object.key("attributes").start_object();
        for (key_220, value_221) in var_218 {
            {
                object_219.key(key_220).string(value_221);
            }
        }
        object_219.finish();
    }
    if let Some(var_222) = &input.next {
        object.key("next").string(var_222);
    }
}

pub fn serialize_structure_remove_attributes_activity(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::RemoveAttributesActivity,
) {
    if let Some(var_223) = &input.name {
        object.key("name").string(var_223);
    }
    if let Some(var_224) = &input.attributes {
        let mut array_225 = object.key("attributes").start_array();
        for item_226 in var_224 {
            {
                array_225.value().string(item_226);
            }
        }
        array_225.finish();
    }
    if let Some(var_227) = &input.next {
        object.key("next").string(var_227);
    }
}

pub fn serialize_structure_select_attributes_activity(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SelectAttributesActivity,
) {
    if let Some(var_228) = &input.name {
        object.key("name").string(var_228);
    }
    if let Some(var_229) = &input.attributes {
        let mut array_230 = object.key("attributes").start_array();
        for item_231 in var_229 {
            {
                array_230.value().string(item_231);
            }
        }
        array_230.finish();
    }
    if let Some(var_232) = &input.next {
        object.key("next").string(var_232);
    }
}

pub fn serialize_structure_filter_activity(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::FilterActivity,
) {
    if let Some(var_233) = &input.name {
        object.key("name").string(var_233);
    }
    if let Some(var_234) = &input.filter {
        object.key("filter").string(var_234);
    }
    if let Some(var_235) = &input.next {
        object.key("next").string(var_235);
    }
}

pub fn serialize_structure_math_activity(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MathActivity,
) {
    if let Some(var_236) = &input.name {
        object.key("name").string(var_236);
    }
    if let Some(var_237) = &input.attribute {
        object.key("attribute").string(var_237);
    }
    if let Some(var_238) = &input.math {
        object.key("math").string(var_238);
    }
    if let Some(var_239) = &input.next {
        object.key("next").string(var_239);
    }
}

pub fn serialize_structure_device_registry_enrich_activity(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DeviceRegistryEnrichActivity,
) {
    if let Some(var_240) = &input.name {
        object.key("name").string(var_240);
    }
    if let Some(var_241) = &input.attribute {
        object.key("attribute").string(var_241);
    }
    if let Some(var_242) = &input.thing_name {
        object.key("thingName").string(var_242);
    }
    if let Some(var_243) = &input.role_arn {
        object.key("roleArn").string(var_243);
    }
    if let Some(var_244) = &input.next {
        object.key("next").string(var_244);
    }
}

pub fn serialize_structure_device_shadow_enrich_activity(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DeviceShadowEnrichActivity,
) {
    if let Some(var_245) = &input.name {
        object.key("name").string(var_245);
    }
    if let Some(var_246) = &input.attribute {
        object.key("attribute").string(var_246);
    }
    if let Some(var_247) = &input.thing_name {
        object.key("thingName").string(var_247);
    }
    if let Some(var_248) = &input.role_arn {
        object.key("roleArn").string(var_248);
    }
    if let Some(var_249) = &input.next {
        object.key("next").string(var_249);
    }
}

pub fn serialize_structure_query_filter(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::QueryFilter,
) {
    if let Some(var_250) = &input.delta_time {
        let mut object_251 = object.key("deltaTime").start_object();
        crate::json_ser::serialize_structure_delta_time(&mut object_251, var_250);
        object_251.finish();
    }
}

pub fn serialize_structure_resource_configuration(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ResourceConfiguration,
) {
    if let Some(var_252) = &input.compute_type {
        object.key("computeType").string(var_252.as_str());
    }
    {
        object.key("volumeSizeInGB").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((input.volume_size_in_gb).into()),
        );
    }
}

pub fn serialize_structure_variable(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Variable,
) {
    if let Some(var_253) = &input.name {
        object.key("name").string(var_253);
    }
    if let Some(var_254) = &input.string_value {
        object.key("stringValue").string(var_254);
    }
    if let Some(var_255) = &input.double_value {
        object.key("doubleValue").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::Float((*var_255).into()),
        );
    }
    if let Some(var_256) = &input.dataset_content_version_value {
        let mut object_257 = object.key("datasetContentVersionValue").start_object();
        crate::json_ser::serialize_structure_dataset_content_version_value(
            &mut object_257,
            var_256,
        );
        object_257.finish();
    }
    if let Some(var_258) = &input.output_file_uri_value {
        let mut object_259 = object.key("outputFileUriValue").start_object();
        crate::json_ser::serialize_structure_output_file_uri_value(&mut object_259, var_258);
        object_259.finish();
    }
}

pub fn serialize_structure_iot_events_destination_configuration(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::IotEventsDestinationConfiguration,
) {
    if let Some(var_260) = &input.input_name {
        object.key("inputName").string(var_260);
    }
    if let Some(var_261) = &input.role_arn {
        object.key("roleArn").string(var_261);
    }
}

pub fn serialize_structure_s3_destination_configuration(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::S3DestinationConfiguration,
) {
    if let Some(var_262) = &input.bucket {
        object.key("bucket").string(var_262);
    }
    if let Some(var_263) = &input.key {
        object.key("key").string(var_263);
    }
    if let Some(var_264) = &input.glue_configuration {
        let mut object_265 = object.key("glueConfiguration").start_object();
        crate::json_ser::serialize_structure_glue_configuration(&mut object_265, var_264);
        object_265.finish();
    }
    if let Some(var_266) = &input.role_arn {
        object.key("roleArn").string(var_266);
    }
}

pub fn serialize_structure_delta_time_session_window_configuration(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DeltaTimeSessionWindowConfiguration,
) {
    if let Some(var_267) = &input.timeout_in_minutes {
        object.key("timeoutInMinutes").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_267).into()),
        );
    }
}

pub fn serialize_structure_partition(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Partition,
) {
    if let Some(var_268) = &input.attribute_name {
        object.key("attributeName").string(var_268);
    }
}

pub fn serialize_structure_timestamp_partition(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TimestampPartition,
) {
    if let Some(var_269) = &input.attribute_name {
        object.key("attributeName").string(var_269);
    }
    if let Some(var_270) = &input.timestamp_format {
        object.key("timestampFormat").string(var_270);
    }
}

pub fn serialize_structure_iot_site_wise_customer_managed_datastore_s3_storage(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::IotSiteWiseCustomerManagedDatastoreS3Storage,
) {
    if let Some(var_271) = &input.bucket {
        object.key("bucket").string(var_271);
    }
    if let Some(var_272) = &input.key_prefix {
        object.key("keyPrefix").string(var_272);
    }
}

pub fn serialize_structure_schema_definition(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::SchemaDefinition,
) {
    if let Some(var_273) = &input.columns {
        let mut array_274 = object.key("columns").start_array();
        for item_275 in var_273 {
            {
                let mut object_276 = array_274.value().start_object();
                crate::json_ser::serialize_structure_column(&mut object_276, item_275);
                object_276.finish();
            }
        }
        array_274.finish();
    }
}

pub fn serialize_structure_delta_time(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DeltaTime,
) {
    if let Some(var_277) = &input.offset_seconds {
        object.key("offsetSeconds").number(
            #[allow(clippy::useless_conversion)]
            smithy_types::Number::NegInt((*var_277).into()),
        );
    }
    if let Some(var_278) = &input.time_expression {
        object.key("timeExpression").string(var_278);
    }
}

pub fn serialize_structure_dataset_content_version_value(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DatasetContentVersionValue,
) {
    if let Some(var_279) = &input.dataset_name {
        object.key("datasetName").string(var_279);
    }
}

pub fn serialize_structure_output_file_uri_value(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::OutputFileUriValue,
) {
    if let Some(var_280) = &input.file_name {
        object.key("fileName").string(var_280);
    }
}

pub fn serialize_structure_glue_configuration(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GlueConfiguration,
) {
    if let Some(var_281) = &input.table_name {
        object.key("tableName").string(var_281);
    }
    if let Some(var_282) = &input.database_name {
        object.key("databaseName").string(var_282);
    }
}

pub fn serialize_structure_column(
    object: &mut smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Column,
) {
    if let Some(var_283) = &input.name {
        object.key("name").string(var_283);
    }
    if let Some(var_284) = &input.r#type {
        object.key("type").string(var_284);
    }
}