pub fn serialize_structure_crate_input_batch_put_message_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchPutMessageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.channel_name {
object.key("channelName").string(var_1.as_str());
}
if let Some(var_2) = &input.messages {
let mut array_3 = object.key("messages").start_array();
for item_4 in var_2 {
{
#[allow(unused_mut)]
let mut object_5 = array_3.value().start_object();
crate::json_ser::serialize_structure_crate_model_message(&mut object_5, item_4)?;
object_5.finish();
}
}
array_3.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_channel_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateChannelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_6) = &input.channel_name {
object.key("channelName").string(var_6.as_str());
}
if let Some(var_7) = &input.channel_storage {
#[allow(unused_mut)]
let mut object_8 = object.key("channelStorage").start_object();
crate::json_ser::serialize_structure_crate_model_channel_storage(&mut object_8, var_7)?;
object_8.finish();
}
if let Some(var_9) = &input.retention_period {
#[allow(unused_mut)]
let mut object_10 = object.key("retentionPeriod").start_object();
crate::json_ser::serialize_structure_crate_model_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 {
{
#[allow(unused_mut)]
let mut object_14 = array_12.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_14, item_13)?;
object_14.finish();
}
}
array_12.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_dataset_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDatasetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_15) = &input.actions {
let mut array_16 = object.key("actions").start_array();
for item_17 in var_15 {
{
#[allow(unused_mut)]
let mut object_18 = array_16.value().start_object();
crate::json_ser::serialize_structure_crate_model_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 {
{
#[allow(unused_mut)]
let mut object_22 = array_20.value().start_object();
crate::json_ser::serialize_structure_crate_model_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.as_str());
}
if let Some(var_24) = &input.late_data_rules {
let mut array_25 = object.key("lateDataRules").start_array();
for item_26 in var_24 {
{
#[allow(unused_mut)]
let mut object_27 = array_25.value().start_object();
crate::json_ser::serialize_structure_crate_model_late_data_rule(
&mut object_27,
item_26,
)?;
object_27.finish();
}
}
array_25.finish();
}
if let Some(var_28) = &input.retention_period {
#[allow(unused_mut)]
let mut object_29 = object.key("retentionPeriod").start_object();
crate::json_ser::serialize_structure_crate_model_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 {
{
#[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();
}
if let Some(var_34) = &input.triggers {
let mut array_35 = object.key("triggers").start_array();
for item_36 in var_34 {
{
#[allow(unused_mut)]
let mut object_37 = array_35.value().start_object();
crate::json_ser::serialize_structure_crate_model_dataset_trigger(
&mut object_37,
item_36,
)?;
object_37.finish();
}
}
array_35.finish();
}
if let Some(var_38) = &input.versioning_configuration {
#[allow(unused_mut)]
let mut object_39 = object.key("versioningConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_versioning_configuration(
&mut object_39,
var_38,
)?;
object_39.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_dataset_content_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDatasetContentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_40) = &input.version_id {
object.key("versionId").string(var_40.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_datastore_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDatastoreInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_41) = &input.datastore_name {
object.key("datastoreName").string(var_41.as_str());
}
if let Some(var_42) = &input.datastore_partitions {
#[allow(unused_mut)]
let mut object_43 = object.key("datastorePartitions").start_object();
crate::json_ser::serialize_structure_crate_model_datastore_partitions(
&mut object_43,
var_42,
)?;
object_43.finish();
}
if let Some(var_44) = &input.datastore_storage {
#[allow(unused_mut)]
let mut object_45 = object.key("datastoreStorage").start_object();
crate::json_ser::serialize_union_crate_model_datastore_storage(&mut object_45, var_44)?;
object_45.finish();
}
if let Some(var_46) = &input.file_format_configuration {
#[allow(unused_mut)]
let mut object_47 = object.key("fileFormatConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_file_format_configuration(
&mut object_47,
var_46,
)?;
object_47.finish();
}
if let Some(var_48) = &input.retention_period {
#[allow(unused_mut)]
let mut object_49 = object.key("retentionPeriod").start_object();
crate::json_ser::serialize_structure_crate_model_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 {
{
#[allow(unused_mut)]
let mut object_53 = array_51.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_53, item_52)?;
object_53.finish();
}
}
array_51.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_pipeline_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreatePipelineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_54) = &input.pipeline_activities {
let mut array_55 = object.key("pipelineActivities").start_array();
for item_56 in var_54 {
{
#[allow(unused_mut)]
let mut object_57 = array_55.value().start_object();
crate::json_ser::serialize_structure_crate_model_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.as_str());
}
if let Some(var_59) = &input.tags {
let mut array_60 = object.key("tags").start_array();
for item_61 in var_59 {
{
#[allow(unused_mut)]
let mut object_62 = array_60.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_62, item_61)?;
object_62.finish();
}
}
array_60.finish();
}
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_63) = &input.logging_options {
#[allow(unused_mut)]
let mut object_64 = object.key("loggingOptions").start_object();
crate::json_ser::serialize_structure_crate_model_logging_options(&mut object_64, var_63)?;
object_64.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_run_pipeline_activity_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RunPipelineActivityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
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(&aws_smithy_types::base64::encode(item_67));
}
}
array_66.finish();
}
if let Some(var_68) = &input.pipeline_activity {
#[allow(unused_mut)]
let mut object_69 = object.key("pipelineActivity").start_object();
crate::json_ser::serialize_structure_crate_model_pipeline_activity(&mut object_69, var_68)?;
object_69.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_pipeline_reprocessing_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartPipelineReprocessingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.channel_messages {
#[allow(unused_mut)]
let mut object_71 = object.key("channelMessages").start_object();
crate::json_ser::serialize_structure_crate_model_channel_messages(&mut object_71, var_70)?;
object_71.finish();
}
if let Some(var_72) = &input.end_time {
object
.key("endTime")
.date_time(var_72, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_73) = &input.start_time {
object
.key("startTime")
.date_time(var_73, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
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_74) = &input.tags {
let mut array_75 = object.key("tags").start_array();
for item_76 in var_74 {
{
#[allow(unused_mut)]
let mut object_77 = array_75.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_77, item_76)?;
object_77.finish();
}
}
array_75.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_channel_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateChannelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_78) = &input.channel_storage {
#[allow(unused_mut)]
let mut object_79 = object.key("channelStorage").start_object();
crate::json_ser::serialize_structure_crate_model_channel_storage(&mut object_79, var_78)?;
object_79.finish();
}
if let Some(var_80) = &input.retention_period {
#[allow(unused_mut)]
let mut object_81 = object.key("retentionPeriod").start_object();
crate::json_ser::serialize_structure_crate_model_retention_period(&mut object_81, var_80)?;
object_81.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_dataset_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDatasetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_82) = &input.actions {
let mut array_83 = object.key("actions").start_array();
for item_84 in var_82 {
{
#[allow(unused_mut)]
let mut object_85 = array_83.value().start_object();
crate::json_ser::serialize_structure_crate_model_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 {
{
#[allow(unused_mut)]
let mut object_89 = array_87.value().start_object();
crate::json_ser::serialize_structure_crate_model_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 {
{
#[allow(unused_mut)]
let mut object_93 = array_91.value().start_object();
crate::json_ser::serialize_structure_crate_model_late_data_rule(
&mut object_93,
item_92,
)?;
object_93.finish();
}
}
array_91.finish();
}
if let Some(var_94) = &input.retention_period {
#[allow(unused_mut)]
let mut object_95 = object.key("retentionPeriod").start_object();
crate::json_ser::serialize_structure_crate_model_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 {
{
#[allow(unused_mut)]
let mut object_99 = array_97.value().start_object();
crate::json_ser::serialize_structure_crate_model_dataset_trigger(
&mut object_99,
item_98,
)?;
object_99.finish();
}
}
array_97.finish();
}
if let Some(var_100) = &input.versioning_configuration {
#[allow(unused_mut)]
let mut object_101 = object.key("versioningConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_versioning_configuration(
&mut object_101,
var_100,
)?;
object_101.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_datastore_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDatastoreInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_102) = &input.datastore_storage {
#[allow(unused_mut)]
let mut object_103 = object.key("datastoreStorage").start_object();
crate::json_ser::serialize_union_crate_model_datastore_storage(&mut object_103, var_102)?;
object_103.finish();
}
if let Some(var_104) = &input.file_format_configuration {
#[allow(unused_mut)]
let mut object_105 = object.key("fileFormatConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_file_format_configuration(
&mut object_105,
var_104,
)?;
object_105.finish();
}
if let Some(var_106) = &input.retention_period {
#[allow(unused_mut)]
let mut object_107 = object.key("retentionPeriod").start_object();
crate::json_ser::serialize_structure_crate_model_retention_period(
&mut object_107,
var_106,
)?;
object_107.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_pipeline_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdatePipelineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_108) = &input.pipeline_activities {
let mut array_109 = object.key("pipelineActivities").start_array();
for item_110 in var_108 {
{
#[allow(unused_mut)]
let mut object_111 = array_109.value().start_object();
crate::json_ser::serialize_structure_crate_model_pipeline_activity(
&mut object_111,
item_110,
)?;
object_111.finish();
}
}
array_109.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_message(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Message,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_112) = &input.message_id {
object.key("messageId").string(var_112.as_str());
}
if let Some(var_113) = &input.payload {
object
.key("payload")
.string_unchecked(&aws_smithy_types::base64::encode(var_113));
}
Ok(())
}
pub fn serialize_structure_crate_model_channel_storage(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ChannelStorage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_114) = &input.service_managed_s3 {
#[allow(unused_mut)]
let mut object_115 = object.key("serviceManagedS3").start_object();
crate::json_ser::serialize_structure_crate_model_service_managed_channel_s3_storage(
&mut object_115,
var_114,
)?;
object_115.finish();
}
if let Some(var_116) = &input.customer_managed_s3 {
#[allow(unused_mut)]
let mut object_117 = object.key("customerManagedS3").start_object();
crate::json_ser::serialize_structure_crate_model_customer_managed_channel_s3_storage(
&mut object_117,
var_116,
)?;
object_117.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_retention_period(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RetentionPeriod,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
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)]
aws_smithy_types::Number::NegInt((*var_118).into()),
);
}
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_119) = &input.key {
object.key("key").string(var_119.as_str());
}
if let Some(var_120) = &input.value {
object.key("value").string(var_120.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_dataset_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatasetAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_121) = &input.action_name {
object.key("actionName").string(var_121.as_str());
}
if let Some(var_122) = &input.query_action {
#[allow(unused_mut)]
let mut object_123 = object.key("queryAction").start_object();
crate::json_ser::serialize_structure_crate_model_sql_query_dataset_action(
&mut object_123,
var_122,
)?;
object_123.finish();
}
if let Some(var_124) = &input.container_action {
#[allow(unused_mut)]
let mut object_125 = object.key("containerAction").start_object();
crate::json_ser::serialize_structure_crate_model_container_dataset_action(
&mut object_125,
var_124,
)?;
object_125.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_dataset_content_delivery_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatasetContentDeliveryRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_126) = &input.entry_name {
object.key("entryName").string(var_126.as_str());
}
if let Some(var_127) = &input.destination {
#[allow(unused_mut)]
let mut object_128 = object.key("destination").start_object();
crate::json_ser::serialize_structure_crate_model_dataset_content_delivery_destination(
&mut object_128,
var_127,
)?;
object_128.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_late_data_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LateDataRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_129) = &input.rule_name {
object.key("ruleName").string(var_129.as_str());
}
if let Some(var_130) = &input.rule_configuration {
#[allow(unused_mut)]
let mut object_131 = object.key("ruleConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_late_data_rule_configuration(
&mut object_131,
var_130,
)?;
object_131.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_dataset_trigger(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatasetTrigger,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_132) = &input.schedule {
#[allow(unused_mut)]
let mut object_133 = object.key("schedule").start_object();
crate::json_ser::serialize_structure_crate_model_schedule(&mut object_133, var_132)?;
object_133.finish();
}
if let Some(var_134) = &input.dataset {
#[allow(unused_mut)]
let mut object_135 = object.key("dataset").start_object();
crate::json_ser::serialize_structure_crate_model_triggering_dataset(
&mut object_135,
var_134,
)?;
object_135.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_versioning_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VersioningConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
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)]
aws_smithy_types::Number::NegInt((*var_136).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_datastore_partitions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatastorePartitions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_137) = &input.partitions {
let mut array_138 = object.key("partitions").start_array();
for item_139 in var_137 {
{
#[allow(unused_mut)]
let mut object_140 = array_138.value().start_object();
crate::json_ser::serialize_structure_crate_model_datastore_partition(
&mut object_140,
item_139,
)?;
object_140.finish();
}
}
array_138.finish();
}
Ok(())
}
pub fn serialize_union_crate_model_datastore_storage(
object_45: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatastoreStorage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::DatastoreStorage::ServiceManagedS3(inner) => {
#[allow(unused_mut)]
let mut object_141 = object_45.key("serviceManagedS3").start_object();
crate::json_ser::serialize_structure_crate_model_service_managed_datastore_s3_storage(
&mut object_141,
inner,
)?;
object_141.finish();
}
crate::model::DatastoreStorage::CustomerManagedS3(inner) => {
#[allow(unused_mut)]
let mut object_142 = object_45.key("customerManagedS3").start_object();
crate::json_ser::serialize_structure_crate_model_customer_managed_datastore_s3_storage(
&mut object_142,
inner,
)?;
object_142.finish();
}
crate::model::DatastoreStorage::IotSiteWiseMultiLayerStorage(inner) => {
#[allow(unused_mut)]
let mut object_143 = object_45.key("iotSiteWiseMultiLayerStorage").start_object();
crate::json_ser::serialize_structure_crate_model_datastore_iot_site_wise_multi_layer_storage(&mut object_143, inner)?;
object_143.finish();
}
crate::model::DatastoreStorage::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"DatastoreStorage",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_file_format_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FileFormatConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_144) = &input.json_configuration {
#[allow(unused_mut)]
let mut object_145 = object.key("jsonConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_json_configuration(
&mut object_145,
var_144,
)?;
object_145.finish();
}
if let Some(var_146) = &input.parquet_configuration {
#[allow(unused_mut)]
let mut object_147 = object.key("parquetConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_parquet_configuration(
&mut object_147,
var_146,
)?;
object_147.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pipeline_activity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipelineActivity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_148) = &input.channel {
#[allow(unused_mut)]
let mut object_149 = object.key("channel").start_object();
crate::json_ser::serialize_structure_crate_model_channel_activity(
&mut object_149,
var_148,
)?;
object_149.finish();
}
if let Some(var_150) = &input.lambda {
#[allow(unused_mut)]
let mut object_151 = object.key("lambda").start_object();
crate::json_ser::serialize_structure_crate_model_lambda_activity(&mut object_151, var_150)?;
object_151.finish();
}
if let Some(var_152) = &input.datastore {
#[allow(unused_mut)]
let mut object_153 = object.key("datastore").start_object();
crate::json_ser::serialize_structure_crate_model_datastore_activity(
&mut object_153,
var_152,
)?;
object_153.finish();
}
if let Some(var_154) = &input.add_attributes {
#[allow(unused_mut)]
let mut object_155 = object.key("addAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_add_attributes_activity(
&mut object_155,
var_154,
)?;
object_155.finish();
}
if let Some(var_156) = &input.remove_attributes {
#[allow(unused_mut)]
let mut object_157 = object.key("removeAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_remove_attributes_activity(
&mut object_157,
var_156,
)?;
object_157.finish();
}
if let Some(var_158) = &input.select_attributes {
#[allow(unused_mut)]
let mut object_159 = object.key("selectAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_select_attributes_activity(
&mut object_159,
var_158,
)?;
object_159.finish();
}
if let Some(var_160) = &input.filter {
#[allow(unused_mut)]
let mut object_161 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_filter_activity(&mut object_161, var_160)?;
object_161.finish();
}
if let Some(var_162) = &input.math {
#[allow(unused_mut)]
let mut object_163 = object.key("math").start_object();
crate::json_ser::serialize_structure_crate_model_math_activity(&mut object_163, var_162)?;
object_163.finish();
}
if let Some(var_164) = &input.device_registry_enrich {
#[allow(unused_mut)]
let mut object_165 = object.key("deviceRegistryEnrich").start_object();
crate::json_ser::serialize_structure_crate_model_device_registry_enrich_activity(
&mut object_165,
var_164,
)?;
object_165.finish();
}
if let Some(var_166) = &input.device_shadow_enrich {
#[allow(unused_mut)]
let mut object_167 = object.key("deviceShadowEnrich").start_object();
crate::json_ser::serialize_structure_crate_model_device_shadow_enrich_activity(
&mut object_167,
var_166,
)?;
object_167.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_168) = &input.role_arn {
object.key("roleArn").string(var_168.as_str());
}
if let Some(var_169) = &input.level {
object.key("level").string(var_169.as_str());
}
{
object.key("enabled").boolean(input.enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_channel_messages(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ChannelMessages,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
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.as_str());
}
}
array_171.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_service_managed_channel_s3_storage(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServiceManagedChannelS3Storage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
Ok(())
}
pub fn serialize_structure_crate_model_customer_managed_channel_s3_storage(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomerManagedChannelS3Storage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_173) = &input.bucket {
object.key("bucket").string(var_173.as_str());
}
if let Some(var_174) = &input.key_prefix {
object.key("keyPrefix").string(var_174.as_str());
}
if let Some(var_175) = &input.role_arn {
object.key("roleArn").string(var_175.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sql_query_dataset_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SqlQueryDatasetAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_176) = &input.sql_query {
object.key("sqlQuery").string(var_176.as_str());
}
if let Some(var_177) = &input.filters {
let mut array_178 = object.key("filters").start_array();
for item_179 in var_177 {
{
#[allow(unused_mut)]
let mut object_180 = array_178.value().start_object();
crate::json_ser::serialize_structure_crate_model_query_filter(
&mut object_180,
item_179,
)?;
object_180.finish();
}
}
array_178.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_container_dataset_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ContainerDatasetAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_181) = &input.image {
object.key("image").string(var_181.as_str());
}
if let Some(var_182) = &input.execution_role_arn {
object.key("executionRoleArn").string(var_182.as_str());
}
if let Some(var_183) = &input.resource_configuration {
#[allow(unused_mut)]
let mut object_184 = object.key("resourceConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_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 {
{
#[allow(unused_mut)]
let mut object_188 = array_186.value().start_object();
crate::json_ser::serialize_structure_crate_model_variable(
&mut object_188,
item_187,
)?;
object_188.finish();
}
}
array_186.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_dataset_content_delivery_destination(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatasetContentDeliveryDestination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_189) = &input.iot_events_destination_configuration {
#[allow(unused_mut)]
let mut object_190 = object
.key("iotEventsDestinationConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_iot_events_destination_configuration(
&mut object_190,
var_189,
)?;
object_190.finish();
}
if let Some(var_191) = &input.s3_destination_configuration {
#[allow(unused_mut)]
let mut object_192 = object.key("s3DestinationConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_s3_destination_configuration(
&mut object_192,
var_191,
)?;
object_192.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_late_data_rule_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LateDataRuleConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_193) = &input.delta_time_session_window_configuration {
#[allow(unused_mut)]
let mut object_194 = object
.key("deltaTimeSessionWindowConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_delta_time_session_window_configuration(
&mut object_194,
var_193,
)?;
object_194.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_schedule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Schedule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_195) = &input.expression {
object.key("expression").string(var_195.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_triggering_dataset(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TriggeringDataset,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_196) = &input.name {
object.key("name").string(var_196.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_datastore_partition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatastorePartition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_197) = &input.attribute_partition {
#[allow(unused_mut)]
let mut object_198 = object.key("attributePartition").start_object();
crate::json_ser::serialize_structure_crate_model_partition(&mut object_198, var_197)?;
object_198.finish();
}
if let Some(var_199) = &input.timestamp_partition {
#[allow(unused_mut)]
let mut object_200 = object.key("timestampPartition").start_object();
crate::json_ser::serialize_structure_crate_model_timestamp_partition(
&mut object_200,
var_199,
)?;
object_200.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_service_managed_datastore_s3_storage(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServiceManagedDatastoreS3Storage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
Ok(())
}
pub fn serialize_structure_crate_model_customer_managed_datastore_s3_storage(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomerManagedDatastoreS3Storage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_201) = &input.bucket {
object.key("bucket").string(var_201.as_str());
}
if let Some(var_202) = &input.key_prefix {
object.key("keyPrefix").string(var_202.as_str());
}
if let Some(var_203) = &input.role_arn {
object.key("roleArn").string(var_203.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_datastore_iot_site_wise_multi_layer_storage(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatastoreIotSiteWiseMultiLayerStorage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_204) = &input.customer_managed_s3_storage {
#[allow(unused_mut)]
let mut object_205 = object.key("customerManagedS3Storage").start_object();
crate::json_ser::serialize_structure_crate_model_iot_site_wise_customer_managed_datastore_s3_storage(&mut object_205, var_204)?;
object_205.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_json_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JsonConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
Ok(())
}
pub fn serialize_structure_crate_model_parquet_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParquetConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_206) = &input.schema_definition {
#[allow(unused_mut)]
let mut object_207 = object.key("schemaDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_schema_definition(
&mut object_207,
var_206,
)?;
object_207.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_channel_activity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ChannelActivity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_208) = &input.name {
object.key("name").string(var_208.as_str());
}
if let Some(var_209) = &input.channel_name {
object.key("channelName").string(var_209.as_str());
}
if let Some(var_210) = &input.next {
object.key("next").string(var_210.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lambda_activity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LambdaActivity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_211) = &input.name {
object.key("name").string(var_211.as_str());
}
if let Some(var_212) = &input.lambda_name {
object.key("lambdaName").string(var_212.as_str());
}
if let Some(var_213) = &input.batch_size {
object.key("batchSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_213).into()),
);
}
if let Some(var_214) = &input.next {
object.key("next").string(var_214.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_datastore_activity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatastoreActivity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_215) = &input.name {
object.key("name").string(var_215.as_str());
}
if let Some(var_216) = &input.datastore_name {
object.key("datastoreName").string(var_216.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_add_attributes_activity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AddAttributesActivity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_217) = &input.name {
object.key("name").string(var_217.as_str());
}
if let Some(var_218) = &input.attributes {
#[allow(unused_mut)]
let mut object_219 = object.key("attributes").start_object();
for (key_220, value_221) in var_218 {
{
object_219.key(key_220.as_str()).string(value_221.as_str());
}
}
object_219.finish();
}
if let Some(var_222) = &input.next {
object.key("next").string(var_222.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_remove_attributes_activity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RemoveAttributesActivity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_223) = &input.name {
object.key("name").string(var_223.as_str());
}
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.as_str());
}
}
array_225.finish();
}
if let Some(var_227) = &input.next {
object.key("next").string(var_227.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_select_attributes_activity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SelectAttributesActivity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_228) = &input.name {
object.key("name").string(var_228.as_str());
}
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.as_str());
}
}
array_230.finish();
}
if let Some(var_232) = &input.next {
object.key("next").string(var_232.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_activity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterActivity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_233) = &input.name {
object.key("name").string(var_233.as_str());
}
if let Some(var_234) = &input.filter {
object.key("filter").string(var_234.as_str());
}
if let Some(var_235) = &input.next {
object.key("next").string(var_235.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_math_activity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MathActivity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_236) = &input.name {
object.key("name").string(var_236.as_str());
}
if let Some(var_237) = &input.attribute {
object.key("attribute").string(var_237.as_str());
}
if let Some(var_238) = &input.math {
object.key("math").string(var_238.as_str());
}
if let Some(var_239) = &input.next {
object.key("next").string(var_239.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_device_registry_enrich_activity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeviceRegistryEnrichActivity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_240) = &input.name {
object.key("name").string(var_240.as_str());
}
if let Some(var_241) = &input.attribute {
object.key("attribute").string(var_241.as_str());
}
if let Some(var_242) = &input.thing_name {
object.key("thingName").string(var_242.as_str());
}
if let Some(var_243) = &input.role_arn {
object.key("roleArn").string(var_243.as_str());
}
if let Some(var_244) = &input.next {
object.key("next").string(var_244.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_device_shadow_enrich_activity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeviceShadowEnrichActivity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_245) = &input.name {
object.key("name").string(var_245.as_str());
}
if let Some(var_246) = &input.attribute {
object.key("attribute").string(var_246.as_str());
}
if let Some(var_247) = &input.thing_name {
object.key("thingName").string(var_247.as_str());
}
if let Some(var_248) = &input.role_arn {
object.key("roleArn").string(var_248.as_str());
}
if let Some(var_249) = &input.next {
object.key("next").string(var_249.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_query_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::QueryFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_250) = &input.delta_time {
#[allow(unused_mut)]
let mut object_251 = object.key("deltaTime").start_object();
crate::json_ser::serialize_structure_crate_model_delta_time(&mut object_251, var_250)?;
object_251.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_252) = &input.compute_type {
object.key("computeType").string(var_252.as_str());
}
{
object.key("volumeSizeInGB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.volume_size_in_gb).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_variable(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Variable,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_253) = &input.name {
object.key("name").string(var_253.as_str());
}
if let Some(var_254) = &input.string_value {
object.key("stringValue").string(var_254.as_str());
}
if let Some(var_255) = &input.double_value {
object.key("doubleValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_255).into()),
);
}
if let Some(var_256) = &input.dataset_content_version_value {
#[allow(unused_mut)]
let mut object_257 = object.key("datasetContentVersionValue").start_object();
crate::json_ser::serialize_structure_crate_model_dataset_content_version_value(
&mut object_257,
var_256,
)?;
object_257.finish();
}
if let Some(var_258) = &input.output_file_uri_value {
#[allow(unused_mut)]
let mut object_259 = object.key("outputFileUriValue").start_object();
crate::json_ser::serialize_structure_crate_model_output_file_uri_value(
&mut object_259,
var_258,
)?;
object_259.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_iot_events_destination_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IotEventsDestinationConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_260) = &input.input_name {
object.key("inputName").string(var_260.as_str());
}
if let Some(var_261) = &input.role_arn {
object.key("roleArn").string(var_261.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_destination_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3DestinationConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_262) = &input.bucket {
object.key("bucket").string(var_262.as_str());
}
if let Some(var_263) = &input.key {
object.key("key").string(var_263.as_str());
}
if let Some(var_264) = &input.glue_configuration {
#[allow(unused_mut)]
let mut object_265 = object.key("glueConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_glue_configuration(
&mut object_265,
var_264,
)?;
object_265.finish();
}
if let Some(var_266) = &input.role_arn {
object.key("roleArn").string(var_266.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_delta_time_session_window_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeltaTimeSessionWindowConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_267) = &input.timeout_in_minutes {
object.key("timeoutInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_267).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_partition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Partition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_268) = &input.attribute_name {
object.key("attributeName").string(var_268.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_timestamp_partition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimestampPartition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_269) = &input.attribute_name {
object.key("attributeName").string(var_269.as_str());
}
if let Some(var_270) = &input.timestamp_format {
object.key("timestampFormat").string(var_270.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_iot_site_wise_customer_managed_datastore_s3_storage(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IotSiteWiseCustomerManagedDatastoreS3Storage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_271) = &input.bucket {
object.key("bucket").string(var_271.as_str());
}
if let Some(var_272) = &input.key_prefix {
object.key("keyPrefix").string(var_272.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_schema_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SchemaDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_273) = &input.columns {
let mut array_274 = object.key("columns").start_array();
for item_275 in var_273 {
{
#[allow(unused_mut)]
let mut object_276 = array_274.value().start_object();
crate::json_ser::serialize_structure_crate_model_column(&mut object_276, item_275)?;
object_276.finish();
}
}
array_274.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_delta_time(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeltaTime,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_277) = &input.offset_seconds {
object.key("offsetSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_277).into()),
);
}
if let Some(var_278) = &input.time_expression {
object.key("timeExpression").string(var_278.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_dataset_content_version_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatasetContentVersionValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_279) = &input.dataset_name {
object.key("datasetName").string(var_279.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_output_file_uri_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OutputFileUriValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_280) = &input.file_name {
object.key("fileName").string(var_280.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_glue_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GlueConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_281) = &input.table_name {
object.key("tableName").string(var_281.as_str());
}
if let Some(var_282) = &input.database_name {
object.key("databaseName").string(var_282.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_column(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Column,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_283) = &input.name {
object.key("name").string(var_283.as_str());
}
if let Some(var_284) = &input.r#type {
object.key("type").string(var_284.as_str());
}
Ok(())
}