pub fn serialize_structure_crate_input_create_pipe_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreatePipeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.description {
object.key("Description").string(var_1.as_str());
}
if let Some(var_2) = &input.desired_state {
object.key("DesiredState").string(var_2.as_str());
}
if let Some(var_3) = &input.enrichment {
object.key("Enrichment").string(var_3.as_str());
}
if let Some(var_4) = &input.enrichment_parameters {
#[allow(unused_mut)]
let mut object_5 = object.key("EnrichmentParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_enrichment_parameters(
&mut object_5,
var_4,
)?;
object_5.finish();
}
if let Some(var_6) = &input.role_arn {
object.key("RoleArn").string(var_6.as_str());
}
if let Some(var_7) = &input.source {
object.key("Source").string(var_7.as_str());
}
if let Some(var_8) = &input.source_parameters {
#[allow(unused_mut)]
let mut object_9 = object.key("SourceParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_source_parameters(
&mut object_9,
var_8,
)?;
object_9.finish();
}
if let Some(var_10) = &input.tags {
#[allow(unused_mut)]
let mut object_11 = object.key("Tags").start_object();
for (key_12, value_13) in var_10 {
{
object_11.key(key_12.as_str()).string(value_13.as_str());
}
}
object_11.finish();
}
if let Some(var_14) = &input.target {
object.key("Target").string(var_14.as_str());
}
if let Some(var_15) = &input.target_parameters {
#[allow(unused_mut)]
let mut object_16 = object.key("TargetParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_target_parameters(
&mut object_16,
var_15,
)?;
object_16.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_17) = &input.tags {
#[allow(unused_mut)]
let mut object_18 = object.key("tags").start_object();
for (key_19, value_20) in var_17 {
{
object_18.key(key_19.as_str()).string(value_20.as_str());
}
}
object_18.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_pipe_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdatePipeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_21) = &input.description {
object.key("Description").string(var_21.as_str());
}
if let Some(var_22) = &input.desired_state {
object.key("DesiredState").string(var_22.as_str());
}
if let Some(var_23) = &input.enrichment {
object.key("Enrichment").string(var_23.as_str());
}
if let Some(var_24) = &input.enrichment_parameters {
#[allow(unused_mut)]
let mut object_25 = object.key("EnrichmentParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_enrichment_parameters(
&mut object_25,
var_24,
)?;
object_25.finish();
}
if let Some(var_26) = &input.role_arn {
object.key("RoleArn").string(var_26.as_str());
}
if let Some(var_27) = &input.source_parameters {
#[allow(unused_mut)]
let mut object_28 = object.key("SourceParameters").start_object();
crate::json_ser::serialize_structure_crate_model_update_pipe_source_parameters(
&mut object_28,
var_27,
)?;
object_28.finish();
}
if let Some(var_29) = &input.target {
object.key("Target").string(var_29.as_str());
}
if let Some(var_30) = &input.target_parameters {
#[allow(unused_mut)]
let mut object_31 = object.key("TargetParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_target_parameters(
&mut object_31,
var_30,
)?;
object_31.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pipe_enrichment_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipeEnrichmentParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_32) = &input.input_template {
object.key("InputTemplate").string(var_32.as_str());
}
if let Some(var_33) = &input.http_parameters {
#[allow(unused_mut)]
let mut object_34 = object.key("HttpParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_enrichment_http_parameters(
&mut object_34,
var_33,
)?;
object_34.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pipe_source_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipeSourceParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.filter_criteria {
#[allow(unused_mut)]
let mut object_36 = object.key("FilterCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_filter_criteria(&mut object_36, var_35)?;
object_36.finish();
}
if let Some(var_37) = &input.kinesis_stream_parameters {
#[allow(unused_mut)]
let mut object_38 = object.key("KinesisStreamParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_source_kinesis_stream_parameters(
&mut object_38,
var_37,
)?;
object_38.finish();
}
if let Some(var_39) = &input.dynamo_db_stream_parameters {
#[allow(unused_mut)]
let mut object_40 = object.key("DynamoDBStreamParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_source_dynamo_db_stream_parameters(
&mut object_40,
var_39,
)?;
object_40.finish();
}
if let Some(var_41) = &input.sqs_queue_parameters {
#[allow(unused_mut)]
let mut object_42 = object.key("SqsQueueParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_source_sqs_queue_parameters(
&mut object_42,
var_41,
)?;
object_42.finish();
}
if let Some(var_43) = &input.active_mq_broker_parameters {
#[allow(unused_mut)]
let mut object_44 = object.key("ActiveMQBrokerParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_source_active_mq_broker_parameters(
&mut object_44,
var_43,
)?;
object_44.finish();
}
if let Some(var_45) = &input.rabbit_mq_broker_parameters {
#[allow(unused_mut)]
let mut object_46 = object.key("RabbitMQBrokerParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_source_rabbit_mq_broker_parameters(
&mut object_46,
var_45,
)?;
object_46.finish();
}
if let Some(var_47) = &input.managed_streaming_kafka_parameters {
#[allow(unused_mut)]
let mut object_48 = object.key("ManagedStreamingKafkaParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_source_managed_streaming_kafka_parameters(&mut object_48, var_47)?;
object_48.finish();
}
if let Some(var_49) = &input.self_managed_kafka_parameters {
#[allow(unused_mut)]
let mut object_50 = object.key("SelfManagedKafkaParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_source_self_managed_kafka_parameters(
&mut object_50,
var_49,
)?;
object_50.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pipe_target_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipeTargetParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_51) = &input.input_template {
object.key("InputTemplate").string(var_51.as_str());
}
if let Some(var_52) = &input.lambda_function_parameters {
#[allow(unused_mut)]
let mut object_53 = object.key("LambdaFunctionParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_target_lambda_function_parameters(
&mut object_53,
var_52,
)?;
object_53.finish();
}
if let Some(var_54) = &input.step_function_state_machine_parameters {
#[allow(unused_mut)]
let mut object_55 = object
.key("StepFunctionStateMachineParameters")
.start_object();
crate::json_ser::serialize_structure_crate_model_pipe_target_state_machine_parameters(
&mut object_55,
var_54,
)?;
object_55.finish();
}
if let Some(var_56) = &input.kinesis_stream_parameters {
#[allow(unused_mut)]
let mut object_57 = object.key("KinesisStreamParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_target_kinesis_stream_parameters(
&mut object_57,
var_56,
)?;
object_57.finish();
}
if let Some(var_58) = &input.ecs_task_parameters {
#[allow(unused_mut)]
let mut object_59 = object.key("EcsTaskParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_target_ecs_task_parameters(
&mut object_59,
var_58,
)?;
object_59.finish();
}
if let Some(var_60) = &input.batch_job_parameters {
#[allow(unused_mut)]
let mut object_61 = object.key("BatchJobParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_target_batch_job_parameters(
&mut object_61,
var_60,
)?;
object_61.finish();
}
if let Some(var_62) = &input.sqs_queue_parameters {
#[allow(unused_mut)]
let mut object_63 = object.key("SqsQueueParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_target_sqs_queue_parameters(
&mut object_63,
var_62,
)?;
object_63.finish();
}
if let Some(var_64) = &input.http_parameters {
#[allow(unused_mut)]
let mut object_65 = object.key("HttpParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_target_http_parameters(
&mut object_65,
var_64,
)?;
object_65.finish();
}
if let Some(var_66) = &input.redshift_data_parameters {
#[allow(unused_mut)]
let mut object_67 = object.key("RedshiftDataParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_target_redshift_data_parameters(
&mut object_67,
var_66,
)?;
object_67.finish();
}
if let Some(var_68) = &input.sage_maker_pipeline_parameters {
#[allow(unused_mut)]
let mut object_69 = object.key("SageMakerPipelineParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_target_sage_maker_pipeline_parameters(&mut object_69, var_68)?;
object_69.finish();
}
if let Some(var_70) = &input.event_bridge_event_bus_parameters {
#[allow(unused_mut)]
let mut object_71 = object.key("EventBridgeEventBusParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_target_event_bridge_event_bus_parameters(&mut object_71, var_70)?;
object_71.finish();
}
if let Some(var_72) = &input.cloud_watch_logs_parameters {
#[allow(unused_mut)]
let mut object_73 = object.key("CloudWatchLogsParameters").start_object();
crate::json_ser::serialize_structure_crate_model_pipe_target_cloud_watch_logs_parameters(
&mut object_73,
var_72,
)?;
object_73.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_pipe_source_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdatePipeSourceParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_74) = &input.filter_criteria {
#[allow(unused_mut)]
let mut object_75 = object.key("FilterCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_filter_criteria(&mut object_75, var_74)?;
object_75.finish();
}
if let Some(var_76) = &input.kinesis_stream_parameters {
#[allow(unused_mut)]
let mut object_77 = object.key("KinesisStreamParameters").start_object();
crate::json_ser::serialize_structure_crate_model_update_pipe_source_kinesis_stream_parameters(&mut object_77, var_76)?;
object_77.finish();
}
if let Some(var_78) = &input.dynamo_db_stream_parameters {
#[allow(unused_mut)]
let mut object_79 = object.key("DynamoDBStreamParameters").start_object();
crate::json_ser::serialize_structure_crate_model_update_pipe_source_dynamo_db_stream_parameters(&mut object_79, var_78)?;
object_79.finish();
}
if let Some(var_80) = &input.sqs_queue_parameters {
#[allow(unused_mut)]
let mut object_81 = object.key("SqsQueueParameters").start_object();
crate::json_ser::serialize_structure_crate_model_update_pipe_source_sqs_queue_parameters(
&mut object_81,
var_80,
)?;
object_81.finish();
}
if let Some(var_82) = &input.active_mq_broker_parameters {
#[allow(unused_mut)]
let mut object_83 = object.key("ActiveMQBrokerParameters").start_object();
crate::json_ser::serialize_structure_crate_model_update_pipe_source_active_mq_broker_parameters(&mut object_83, var_82)?;
object_83.finish();
}
if let Some(var_84) = &input.rabbit_mq_broker_parameters {
#[allow(unused_mut)]
let mut object_85 = object.key("RabbitMQBrokerParameters").start_object();
crate::json_ser::serialize_structure_crate_model_update_pipe_source_rabbit_mq_broker_parameters(&mut object_85, var_84)?;
object_85.finish();
}
if let Some(var_86) = &input.managed_streaming_kafka_parameters {
#[allow(unused_mut)]
let mut object_87 = object.key("ManagedStreamingKafkaParameters").start_object();
crate::json_ser::serialize_structure_crate_model_update_pipe_source_managed_streaming_kafka_parameters(&mut object_87, var_86)?;
object_87.finish();
}
if let Some(var_88) = &input.self_managed_kafka_parameters {
#[allow(unused_mut)]
let mut object_89 = object.key("SelfManagedKafkaParameters").start_object();
crate::json_ser::serialize_structure_crate_model_update_pipe_source_self_managed_kafka_parameters(&mut object_89, var_88)?;
object_89.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pipe_enrichment_http_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipeEnrichmentHttpParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_90) = &input.path_parameter_values {
let mut array_91 = object.key("PathParameterValues").start_array();
for item_92 in var_90 {
{
array_91.value().string(item_92.as_str());
}
}
array_91.finish();
}
if let Some(var_93) = &input.header_parameters {
#[allow(unused_mut)]
let mut object_94 = object.key("HeaderParameters").start_object();
for (key_95, value_96) in var_93 {
{
object_94.key(key_95.as_str()).string(value_96.as_str());
}
}
object_94.finish();
}
if let Some(var_97) = &input.query_string_parameters {
#[allow(unused_mut)]
let mut object_98 = object.key("QueryStringParameters").start_object();
for (key_99, value_100) in var_97 {
{
object_98.key(key_99.as_str()).string(value_100.as_str());
}
}
object_98.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_101) = &input.filters {
let mut array_102 = object.key("Filters").start_array();
for item_103 in var_101 {
{
#[allow(unused_mut)]
let mut object_104 = array_102.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_104, item_103)?;
object_104.finish();
}
}
array_102.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pipe_source_kinesis_stream_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipeSourceKinesisStreamParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_105) = &input.batch_size {
object.key("BatchSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_105).into()),
);
}
if let Some(var_106) = &input.dead_letter_config {
#[allow(unused_mut)]
let mut object_107 = object.key("DeadLetterConfig").start_object();
crate::json_ser::serialize_structure_crate_model_dead_letter_config(
&mut object_107,
var_106,
)?;
object_107.finish();
}
if let Some(var_108) = &input.on_partial_batch_item_failure {
object
.key("OnPartialBatchItemFailure")
.string(var_108.as_str());
}
if let Some(var_109) = &input.maximum_batching_window_in_seconds {
object.key("MaximumBatchingWindowInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_109).into()),
);
}
if let Some(var_110) = &input.maximum_record_age_in_seconds {
object.key("MaximumRecordAgeInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_110).into()),
);
}
if let Some(var_111) = &input.maximum_retry_attempts {
object.key("MaximumRetryAttempts").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_111).into()),
);
}
if let Some(var_112) = &input.parallelization_factor {
object.key("ParallelizationFactor").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_112).into()),
);
}
if let Some(var_113) = &input.starting_position {
object.key("StartingPosition").string(var_113.as_str());
}
if let Some(var_114) = &input.starting_position_timestamp {
object
.key("StartingPositionTimestamp")
.date_time(var_114, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_pipe_source_dynamo_db_stream_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipeSourceDynamoDbStreamParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_115) = &input.batch_size {
object.key("BatchSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_115).into()),
);
}
if let Some(var_116) = &input.dead_letter_config {
#[allow(unused_mut)]
let mut object_117 = object.key("DeadLetterConfig").start_object();
crate::json_ser::serialize_structure_crate_model_dead_letter_config(
&mut object_117,
var_116,
)?;
object_117.finish();
}
if let Some(var_118) = &input.on_partial_batch_item_failure {
object
.key("OnPartialBatchItemFailure")
.string(var_118.as_str());
}
if let Some(var_119) = &input.maximum_batching_window_in_seconds {
object.key("MaximumBatchingWindowInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_119).into()),
);
}
if let Some(var_120) = &input.maximum_record_age_in_seconds {
object.key("MaximumRecordAgeInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_120).into()),
);
}
if let Some(var_121) = &input.maximum_retry_attempts {
object.key("MaximumRetryAttempts").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_121).into()),
);
}
if let Some(var_122) = &input.parallelization_factor {
object.key("ParallelizationFactor").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_122).into()),
);
}
if let Some(var_123) = &input.starting_position {
object.key("StartingPosition").string(var_123.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_pipe_source_sqs_queue_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipeSourceSqsQueueParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_124) = &input.batch_size {
object.key("BatchSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_124).into()),
);
}
if let Some(var_125) = &input.maximum_batching_window_in_seconds {
object.key("MaximumBatchingWindowInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_125).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_pipe_source_active_mq_broker_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipeSourceActiveMqBrokerParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_126) = &input.credentials {
#[allow(unused_mut)]
let mut object_127 = object.key("Credentials").start_object();
crate::json_ser::serialize_union_crate_model_mq_broker_access_credentials(
&mut object_127,
var_126,
)?;
object_127.finish();
}
if let Some(var_128) = &input.queue_name {
object.key("QueueName").string(var_128.as_str());
}
if let Some(var_129) = &input.batch_size {
object.key("BatchSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_129).into()),
);
}
if let Some(var_130) = &input.maximum_batching_window_in_seconds {
object.key("MaximumBatchingWindowInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_130).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_pipe_source_rabbit_mq_broker_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipeSourceRabbitMqBrokerParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_131) = &input.credentials {
#[allow(unused_mut)]
let mut object_132 = object.key("Credentials").start_object();
crate::json_ser::serialize_union_crate_model_mq_broker_access_credentials(
&mut object_132,
var_131,
)?;
object_132.finish();
}
if let Some(var_133) = &input.queue_name {
object.key("QueueName").string(var_133.as_str());
}
if let Some(var_134) = &input.virtual_host {
object.key("VirtualHost").string(var_134.as_str());
}
if let Some(var_135) = &input.batch_size {
object.key("BatchSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_135).into()),
);
}
if let Some(var_136) = &input.maximum_batching_window_in_seconds {
object.key("MaximumBatchingWindowInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_136).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_pipe_source_managed_streaming_kafka_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipeSourceManagedStreamingKafkaParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_137) = &input.topic_name {
object.key("TopicName").string(var_137.as_str());
}
if let Some(var_138) = &input.starting_position {
object.key("StartingPosition").string(var_138.as_str());
}
if let Some(var_139) = &input.batch_size {
object.key("BatchSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_139).into()),
);
}
if let Some(var_140) = &input.maximum_batching_window_in_seconds {
object.key("MaximumBatchingWindowInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_140).into()),
);
}
if let Some(var_141) = &input.consumer_group_id {
object.key("ConsumerGroupID").string(var_141.as_str());
}
if let Some(var_142) = &input.credentials {
#[allow(unused_mut)]
let mut object_143 = object.key("Credentials").start_object();
crate::json_ser::serialize_union_crate_model_msk_access_credentials(
&mut object_143,
var_142,
)?;
object_143.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pipe_source_self_managed_kafka_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipeSourceSelfManagedKafkaParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_144) = &input.topic_name {
object.key("TopicName").string(var_144.as_str());
}
if let Some(var_145) = &input.starting_position {
object.key("StartingPosition").string(var_145.as_str());
}
if let Some(var_146) = &input.additional_bootstrap_servers {
let mut array_147 = object.key("AdditionalBootstrapServers").start_array();
for item_148 in var_146 {
{
array_147.value().string(item_148.as_str());
}
}
array_147.finish();
}
if let Some(var_149) = &input.batch_size {
object.key("BatchSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_149).into()),
);
}
if let Some(var_150) = &input.maximum_batching_window_in_seconds {
object.key("MaximumBatchingWindowInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_150).into()),
);
}
if let Some(var_151) = &input.consumer_group_id {
object.key("ConsumerGroupID").string(var_151.as_str());
}
if let Some(var_152) = &input.credentials {
#[allow(unused_mut)]
let mut object_153 = object.key("Credentials").start_object();
crate::json_ser::serialize_union_crate_model_self_managed_kafka_access_configuration_credentials(&mut object_153, var_152)?;
object_153.finish();
}
if let Some(var_154) = &input.server_root_ca_certificate {
object
.key("ServerRootCaCertificate")
.string(var_154.as_str());
}
if let Some(var_155) = &input.vpc {
#[allow(unused_mut)]
let mut object_156 = object.key("Vpc").start_object();
crate::json_ser::serialize_structure_crate_model_self_managed_kafka_access_configuration_vpc(&mut object_156, var_155)?;
object_156.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pipe_target_lambda_function_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipeTargetLambdaFunctionParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_157) = &input.invocation_type {
object.key("InvocationType").string(var_157.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_pipe_target_state_machine_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipeTargetStateMachineParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_158) = &input.invocation_type {
object.key("InvocationType").string(var_158.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_pipe_target_kinesis_stream_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipeTargetKinesisStreamParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_159) = &input.partition_key {
object.key("PartitionKey").string(var_159.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_pipe_target_ecs_task_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipeTargetEcsTaskParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_160) = &input.task_definition_arn {
object.key("TaskDefinitionArn").string(var_160.as_str());
}
if let Some(var_161) = &input.task_count {
object.key("TaskCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_161).into()),
);
}
if let Some(var_162) = &input.launch_type {
object.key("LaunchType").string(var_162.as_str());
}
if let Some(var_163) = &input.network_configuration {
#[allow(unused_mut)]
let mut object_164 = object.key("NetworkConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_network_configuration(
&mut object_164,
var_163,
)?;
object_164.finish();
}
if let Some(var_165) = &input.platform_version {
object.key("PlatformVersion").string(var_165.as_str());
}
if let Some(var_166) = &input.group {
object.key("Group").string(var_166.as_str());
}
if let Some(var_167) = &input.capacity_provider_strategy {
let mut array_168 = object.key("CapacityProviderStrategy").start_array();
for item_169 in var_167 {
{
#[allow(unused_mut)]
let mut object_170 = array_168.value().start_object();
crate::json_ser::serialize_structure_crate_model_capacity_provider_strategy_item(
&mut object_170,
item_169,
)?;
object_170.finish();
}
}
array_168.finish();
}
if input.enable_ecs_managed_tags {
object
.key("EnableECSManagedTags")
.boolean(input.enable_ecs_managed_tags);
}
if input.enable_execute_command {
object
.key("EnableExecuteCommand")
.boolean(input.enable_execute_command);
}
if let Some(var_171) = &input.placement_constraints {
let mut array_172 = object.key("PlacementConstraints").start_array();
for item_173 in var_171 {
{
#[allow(unused_mut)]
let mut object_174 = array_172.value().start_object();
crate::json_ser::serialize_structure_crate_model_placement_constraint(
&mut object_174,
item_173,
)?;
object_174.finish();
}
}
array_172.finish();
}
if let Some(var_175) = &input.placement_strategy {
let mut array_176 = object.key("PlacementStrategy").start_array();
for item_177 in var_175 {
{
#[allow(unused_mut)]
let mut object_178 = array_176.value().start_object();
crate::json_ser::serialize_structure_crate_model_placement_strategy(
&mut object_178,
item_177,
)?;
object_178.finish();
}
}
array_176.finish();
}
if let Some(var_179) = &input.propagate_tags {
object.key("PropagateTags").string(var_179.as_str());
}
if let Some(var_180) = &input.reference_id {
object.key("ReferenceId").string(var_180.as_str());
}
if let Some(var_181) = &input.overrides {
#[allow(unused_mut)]
let mut object_182 = object.key("Overrides").start_object();
crate::json_ser::serialize_structure_crate_model_ecs_task_override(
&mut object_182,
var_181,
)?;
object_182.finish();
}
if let Some(var_183) = &input.tags {
let mut array_184 = object.key("Tags").start_array();
for item_185 in var_183 {
{
#[allow(unused_mut)]
let mut object_186 = array_184.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_186, item_185)?;
object_186.finish();
}
}
array_184.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pipe_target_batch_job_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipeTargetBatchJobParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_187) = &input.job_definition {
object.key("JobDefinition").string(var_187.as_str());
}
if let Some(var_188) = &input.job_name {
object.key("JobName").string(var_188.as_str());
}
if let Some(var_189) = &input.array_properties {
#[allow(unused_mut)]
let mut object_190 = object.key("ArrayProperties").start_object();
crate::json_ser::serialize_structure_crate_model_batch_array_properties(
&mut object_190,
var_189,
)?;
object_190.finish();
}
if let Some(var_191) = &input.retry_strategy {
#[allow(unused_mut)]
let mut object_192 = object.key("RetryStrategy").start_object();
crate::json_ser::serialize_structure_crate_model_batch_retry_strategy(
&mut object_192,
var_191,
)?;
object_192.finish();
}
if let Some(var_193) = &input.container_overrides {
#[allow(unused_mut)]
let mut object_194 = object.key("ContainerOverrides").start_object();
crate::json_ser::serialize_structure_crate_model_batch_container_overrides(
&mut object_194,
var_193,
)?;
object_194.finish();
}
if let Some(var_195) = &input.depends_on {
let mut array_196 = object.key("DependsOn").start_array();
for item_197 in var_195 {
{
#[allow(unused_mut)]
let mut object_198 = array_196.value().start_object();
crate::json_ser::serialize_structure_crate_model_batch_job_dependency(
&mut object_198,
item_197,
)?;
object_198.finish();
}
}
array_196.finish();
}
if let Some(var_199) = &input.parameters {
#[allow(unused_mut)]
let mut object_200 = object.key("Parameters").start_object();
for (key_201, value_202) in var_199 {
{
object_200.key(key_201.as_str()).string(value_202.as_str());
}
}
object_200.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pipe_target_sqs_queue_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipeTargetSqsQueueParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_203) = &input.message_group_id {
object.key("MessageGroupId").string(var_203.as_str());
}
if let Some(var_204) = &input.message_deduplication_id {
object
.key("MessageDeduplicationId")
.string(var_204.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_pipe_target_http_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipeTargetHttpParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_205) = &input.path_parameter_values {
let mut array_206 = object.key("PathParameterValues").start_array();
for item_207 in var_205 {
{
array_206.value().string(item_207.as_str());
}
}
array_206.finish();
}
if let Some(var_208) = &input.header_parameters {
#[allow(unused_mut)]
let mut object_209 = object.key("HeaderParameters").start_object();
for (key_210, value_211) in var_208 {
{
object_209.key(key_210.as_str()).string(value_211.as_str());
}
}
object_209.finish();
}
if let Some(var_212) = &input.query_string_parameters {
#[allow(unused_mut)]
let mut object_213 = object.key("QueryStringParameters").start_object();
for (key_214, value_215) in var_212 {
{
object_213.key(key_214.as_str()).string(value_215.as_str());
}
}
object_213.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pipe_target_redshift_data_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipeTargetRedshiftDataParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_216) = &input.secret_manager_arn {
object.key("SecretManagerArn").string(var_216.as_str());
}
if let Some(var_217) = &input.database {
object.key("Database").string(var_217.as_str());
}
if let Some(var_218) = &input.db_user {
object.key("DbUser").string(var_218.as_str());
}
if let Some(var_219) = &input.statement_name {
object.key("StatementName").string(var_219.as_str());
}
if input.with_event {
object.key("WithEvent").boolean(input.with_event);
}
if let Some(var_220) = &input.sqls {
let mut array_221 = object.key("Sqls").start_array();
for item_222 in var_220 {
{
array_221.value().string(item_222.as_str());
}
}
array_221.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pipe_target_sage_maker_pipeline_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipeTargetSageMakerPipelineParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_223) = &input.pipeline_parameter_list {
let mut array_224 = object.key("PipelineParameterList").start_array();
for item_225 in var_223 {
{
#[allow(unused_mut)]
let mut object_226 = array_224.value().start_object();
crate::json_ser::serialize_structure_crate_model_sage_maker_pipeline_parameter(
&mut object_226,
item_225,
)?;
object_226.finish();
}
}
array_224.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_pipe_target_event_bridge_event_bus_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipeTargetEventBridgeEventBusParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_227) = &input.endpoint_id {
object.key("EndpointId").string(var_227.as_str());
}
if let Some(var_228) = &input.detail_type {
object.key("DetailType").string(var_228.as_str());
}
if let Some(var_229) = &input.source {
object.key("Source").string(var_229.as_str());
}
if let Some(var_230) = &input.resources {
let mut array_231 = object.key("Resources").start_array();
for item_232 in var_230 {
{
array_231.value().string(item_232.as_str());
}
}
array_231.finish();
}
if let Some(var_233) = &input.time {
object.key("Time").string(var_233.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_pipe_target_cloud_watch_logs_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipeTargetCloudWatchLogsParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_234) = &input.log_stream_name {
object.key("LogStreamName").string(var_234.as_str());
}
if let Some(var_235) = &input.timestamp {
object.key("Timestamp").string(var_235.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update_pipe_source_kinesis_stream_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdatePipeSourceKinesisStreamParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_236) = &input.batch_size {
object.key("BatchSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_236).into()),
);
}
if let Some(var_237) = &input.dead_letter_config {
#[allow(unused_mut)]
let mut object_238 = object.key("DeadLetterConfig").start_object();
crate::json_ser::serialize_structure_crate_model_dead_letter_config(
&mut object_238,
var_237,
)?;
object_238.finish();
}
if let Some(var_239) = &input.on_partial_batch_item_failure {
object
.key("OnPartialBatchItemFailure")
.string(var_239.as_str());
}
if let Some(var_240) = &input.maximum_batching_window_in_seconds {
object.key("MaximumBatchingWindowInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_240).into()),
);
}
if let Some(var_241) = &input.maximum_record_age_in_seconds {
object.key("MaximumRecordAgeInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_241).into()),
);
}
if let Some(var_242) = &input.maximum_retry_attempts {
object.key("MaximumRetryAttempts").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_242).into()),
);
}
if let Some(var_243) = &input.parallelization_factor {
object.key("ParallelizationFactor").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_243).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_update_pipe_source_dynamo_db_stream_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdatePipeSourceDynamoDbStreamParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_244) = &input.batch_size {
object.key("BatchSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_244).into()),
);
}
if let Some(var_245) = &input.dead_letter_config {
#[allow(unused_mut)]
let mut object_246 = object.key("DeadLetterConfig").start_object();
crate::json_ser::serialize_structure_crate_model_dead_letter_config(
&mut object_246,
var_245,
)?;
object_246.finish();
}
if let Some(var_247) = &input.on_partial_batch_item_failure {
object
.key("OnPartialBatchItemFailure")
.string(var_247.as_str());
}
if let Some(var_248) = &input.maximum_batching_window_in_seconds {
object.key("MaximumBatchingWindowInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_248).into()),
);
}
if let Some(var_249) = &input.maximum_record_age_in_seconds {
object.key("MaximumRecordAgeInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_249).into()),
);
}
if let Some(var_250) = &input.maximum_retry_attempts {
object.key("MaximumRetryAttempts").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_250).into()),
);
}
if let Some(var_251) = &input.parallelization_factor {
object.key("ParallelizationFactor").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_251).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_update_pipe_source_sqs_queue_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdatePipeSourceSqsQueueParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_252) = &input.batch_size {
object.key("BatchSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_252).into()),
);
}
if let Some(var_253) = &input.maximum_batching_window_in_seconds {
object.key("MaximumBatchingWindowInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_253).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_update_pipe_source_active_mq_broker_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdatePipeSourceActiveMqBrokerParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_254) = &input.credentials {
#[allow(unused_mut)]
let mut object_255 = object.key("Credentials").start_object();
crate::json_ser::serialize_union_crate_model_mq_broker_access_credentials(
&mut object_255,
var_254,
)?;
object_255.finish();
}
if let Some(var_256) = &input.batch_size {
object.key("BatchSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_256).into()),
);
}
if let Some(var_257) = &input.maximum_batching_window_in_seconds {
object.key("MaximumBatchingWindowInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_257).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_update_pipe_source_rabbit_mq_broker_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdatePipeSourceRabbitMqBrokerParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_258) = &input.credentials {
#[allow(unused_mut)]
let mut object_259 = object.key("Credentials").start_object();
crate::json_ser::serialize_union_crate_model_mq_broker_access_credentials(
&mut object_259,
var_258,
)?;
object_259.finish();
}
if let Some(var_260) = &input.batch_size {
object.key("BatchSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_260).into()),
);
}
if let Some(var_261) = &input.maximum_batching_window_in_seconds {
object.key("MaximumBatchingWindowInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_261).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_update_pipe_source_managed_streaming_kafka_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdatePipeSourceManagedStreamingKafkaParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_262) = &input.batch_size {
object.key("BatchSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_262).into()),
);
}
if let Some(var_263) = &input.credentials {
#[allow(unused_mut)]
let mut object_264 = object.key("Credentials").start_object();
crate::json_ser::serialize_union_crate_model_msk_access_credentials(
&mut object_264,
var_263,
)?;
object_264.finish();
}
if let Some(var_265) = &input.maximum_batching_window_in_seconds {
object.key("MaximumBatchingWindowInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_265).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_update_pipe_source_self_managed_kafka_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdatePipeSourceSelfManagedKafkaParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_266) = &input.batch_size {
object.key("BatchSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_266).into()),
);
}
if let Some(var_267) = &input.maximum_batching_window_in_seconds {
object.key("MaximumBatchingWindowInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_267).into()),
);
}
if let Some(var_268) = &input.credentials {
#[allow(unused_mut)]
let mut object_269 = object.key("Credentials").start_object();
crate::json_ser::serialize_union_crate_model_self_managed_kafka_access_configuration_credentials(&mut object_269, var_268)?;
object_269.finish();
}
if let Some(var_270) = &input.server_root_ca_certificate {
object
.key("ServerRootCaCertificate")
.string(var_270.as_str());
}
if let Some(var_271) = &input.vpc {
#[allow(unused_mut)]
let mut object_272 = object.key("Vpc").start_object();
crate::json_ser::serialize_structure_crate_model_self_managed_kafka_access_configuration_vpc(&mut object_272, var_271)?;
object_272.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Filter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_273) = &input.pattern {
object.key("Pattern").string(var_273.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_dead_letter_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeadLetterConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_274) = &input.arn {
object.key("Arn").string(var_274.as_str());
}
Ok(())
}
pub fn serialize_union_crate_model_mq_broker_access_credentials(
object_127: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MqBrokerAccessCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::MqBrokerAccessCredentials::BasicAuth(inner) => {
object_127.key("BasicAuth").string(inner.as_str());
}
crate::model::MqBrokerAccessCredentials::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"MqBrokerAccessCredentials",
),
)
}
}
Ok(())
}
pub fn serialize_union_crate_model_msk_access_credentials(
object_143: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MskAccessCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::MskAccessCredentials::SaslScram512Auth(inner) => {
object_143.key("SaslScram512Auth").string(inner.as_str());
}
crate::model::MskAccessCredentials::ClientCertificateTlsAuth(inner) => {
object_143
.key("ClientCertificateTlsAuth")
.string(inner.as_str());
}
crate::model::MskAccessCredentials::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"MskAccessCredentials",
),
)
}
}
Ok(())
}
pub fn serialize_union_crate_model_self_managed_kafka_access_configuration_credentials(
object_153: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SelfManagedKafkaAccessConfigurationCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::SelfManagedKafkaAccessConfigurationCredentials::BasicAuth(inner) => {
object_153.key("BasicAuth").string(inner.as_str());
}
crate::model::SelfManagedKafkaAccessConfigurationCredentials::SaslScram512Auth(inner) => {
object_153.key("SaslScram512Auth").string(inner.as_str());
}
crate::model::SelfManagedKafkaAccessConfigurationCredentials::SaslScram256Auth(inner) => {
object_153.key("SaslScram256Auth").string(inner.as_str());
}
crate::model::SelfManagedKafkaAccessConfigurationCredentials::ClientCertificateTlsAuth(
inner,
) => {
object_153
.key("ClientCertificateTlsAuth")
.string(inner.as_str());
}
crate::model::SelfManagedKafkaAccessConfigurationCredentials::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"SelfManagedKafkaAccessConfigurationCredentials",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_self_managed_kafka_access_configuration_vpc(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SelfManagedKafkaAccessConfigurationVpc,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_275) = &input.subnets {
let mut array_276 = object.key("Subnets").start_array();
for item_277 in var_275 {
{
array_276.value().string(item_277.as_str());
}
}
array_276.finish();
}
if let Some(var_278) = &input.security_group {
let mut array_279 = object.key("SecurityGroup").start_array();
for item_280 in var_278 {
{
array_279.value().string(item_280.as_str());
}
}
array_279.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_network_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NetworkConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_281) = &input.awsvpc_configuration {
#[allow(unused_mut)]
let mut object_282 = object.key("awsvpcConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_vpc_configuration(
&mut object_282,
var_281,
)?;
object_282.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_capacity_provider_strategy_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CapacityProviderStrategyItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_283) = &input.capacity_provider {
object.key("capacityProvider").string(var_283.as_str());
}
if input.weight != 0 {
object.key("weight").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.weight).into()),
);
}
if input.base != 0 {
object.key("base").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.base).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_placement_constraint(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PlacementConstraint,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_284) = &input.r#type {
object.key("type").string(var_284.as_str());
}
if let Some(var_285) = &input.expression {
object.key("expression").string(var_285.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_placement_strategy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PlacementStrategy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_286) = &input.r#type {
object.key("type").string(var_286.as_str());
}
if let Some(var_287) = &input.field {
object.key("field").string(var_287.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ecs_task_override(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EcsTaskOverride,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_288) = &input.container_overrides {
let mut array_289 = object.key("ContainerOverrides").start_array();
for item_290 in var_288 {
{
#[allow(unused_mut)]
let mut object_291 = array_289.value().start_object();
crate::json_ser::serialize_structure_crate_model_ecs_container_override(
&mut object_291,
item_290,
)?;
object_291.finish();
}
}
array_289.finish();
}
if let Some(var_292) = &input.cpu {
object.key("Cpu").string(var_292.as_str());
}
if let Some(var_293) = &input.ephemeral_storage {
#[allow(unused_mut)]
let mut object_294 = object.key("EphemeralStorage").start_object();
crate::json_ser::serialize_structure_crate_model_ecs_ephemeral_storage(
&mut object_294,
var_293,
)?;
object_294.finish();
}
if let Some(var_295) = &input.execution_role_arn {
object.key("ExecutionRoleArn").string(var_295.as_str());
}
if let Some(var_296) = &input.inference_accelerator_overrides {
let mut array_297 = object.key("InferenceAcceleratorOverrides").start_array();
for item_298 in var_296 {
{
#[allow(unused_mut)]
let mut object_299 = array_297.value().start_object();
crate::json_ser::serialize_structure_crate_model_ecs_inference_accelerator_override(&mut object_299, item_298)?;
object_299.finish();
}
}
array_297.finish();
}
if let Some(var_300) = &input.memory {
object.key("Memory").string(var_300.as_str());
}
if let Some(var_301) = &input.task_role_arn {
object.key("TaskRoleArn").string(var_301.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_302) = &input.key {
object.key("Key").string(var_302.as_str());
}
if let Some(var_303) = &input.value {
object.key("Value").string(var_303.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_batch_array_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BatchArrayProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.size != 0 {
object.key("Size").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.size).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_batch_retry_strategy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BatchRetryStrategy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.attempts != 0 {
object.key("Attempts").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.attempts).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_batch_container_overrides(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BatchContainerOverrides,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_304) = &input.command {
let mut array_305 = object.key("Command").start_array();
for item_306 in var_304 {
{
array_305.value().string(item_306.as_str());
}
}
array_305.finish();
}
if let Some(var_307) = &input.environment {
let mut array_308 = object.key("Environment").start_array();
for item_309 in var_307 {
{
#[allow(unused_mut)]
let mut object_310 = array_308.value().start_object();
crate::json_ser::serialize_structure_crate_model_batch_environment_variable(
&mut object_310,
item_309,
)?;
object_310.finish();
}
}
array_308.finish();
}
if let Some(var_311) = &input.instance_type {
object.key("InstanceType").string(var_311.as_str());
}
if let Some(var_312) = &input.resource_requirements {
let mut array_313 = object.key("ResourceRequirements").start_array();
for item_314 in var_312 {
{
#[allow(unused_mut)]
let mut object_315 = array_313.value().start_object();
crate::json_ser::serialize_structure_crate_model_batch_resource_requirement(
&mut object_315,
item_314,
)?;
object_315.finish();
}
}
array_313.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_batch_job_dependency(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BatchJobDependency,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_316) = &input.job_id {
object.key("JobId").string(var_316.as_str());
}
if let Some(var_317) = &input.r#type {
object.key("Type").string(var_317.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sage_maker_pipeline_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SageMakerPipelineParameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_318) = &input.name {
object.key("Name").string(var_318.as_str());
}
if let Some(var_319) = &input.value {
object.key("Value").string(var_319.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_vpc_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsVpcConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_320) = &input.subnets {
let mut array_321 = object.key("Subnets").start_array();
for item_322 in var_320 {
{
array_321.value().string(item_322.as_str());
}
}
array_321.finish();
}
if let Some(var_323) = &input.security_groups {
let mut array_324 = object.key("SecurityGroups").start_array();
for item_325 in var_323 {
{
array_324.value().string(item_325.as_str());
}
}
array_324.finish();
}
if let Some(var_326) = &input.assign_public_ip {
object.key("AssignPublicIp").string(var_326.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ecs_container_override(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EcsContainerOverride,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_327) = &input.command {
let mut array_328 = object.key("Command").start_array();
for item_329 in var_327 {
{
array_328.value().string(item_329.as_str());
}
}
array_328.finish();
}
if let Some(var_330) = &input.cpu {
object.key("Cpu").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_330).into()),
);
}
if let Some(var_331) = &input.environment {
let mut array_332 = object.key("Environment").start_array();
for item_333 in var_331 {
{
#[allow(unused_mut)]
let mut object_334 = array_332.value().start_object();
crate::json_ser::serialize_structure_crate_model_ecs_environment_variable(
&mut object_334,
item_333,
)?;
object_334.finish();
}
}
array_332.finish();
}
if let Some(var_335) = &input.environment_files {
let mut array_336 = object.key("EnvironmentFiles").start_array();
for item_337 in var_335 {
{
#[allow(unused_mut)]
let mut object_338 = array_336.value().start_object();
crate::json_ser::serialize_structure_crate_model_ecs_environment_file(
&mut object_338,
item_337,
)?;
object_338.finish();
}
}
array_336.finish();
}
if let Some(var_339) = &input.memory {
object.key("Memory").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_339).into()),
);
}
if let Some(var_340) = &input.memory_reservation {
object.key("MemoryReservation").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_340).into()),
);
}
if let Some(var_341) = &input.name {
object.key("Name").string(var_341.as_str());
}
if let Some(var_342) = &input.resource_requirements {
let mut array_343 = object.key("ResourceRequirements").start_array();
for item_344 in var_342 {
{
#[allow(unused_mut)]
let mut object_345 = array_343.value().start_object();
crate::json_ser::serialize_structure_crate_model_ecs_resource_requirement(
&mut object_345,
item_344,
)?;
object_345.finish();
}
}
array_343.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_ecs_ephemeral_storage(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EcsEphemeralStorage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("sizeInGiB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.size_in_gi_b).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_ecs_inference_accelerator_override(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EcsInferenceAcceleratorOverride,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_346) = &input.device_name {
object.key("deviceName").string(var_346.as_str());
}
if let Some(var_347) = &input.device_type {
object.key("deviceType").string(var_347.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_batch_environment_variable(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BatchEnvironmentVariable,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_348) = &input.name {
object.key("Name").string(var_348.as_str());
}
if let Some(var_349) = &input.value {
object.key("Value").string(var_349.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_batch_resource_requirement(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BatchResourceRequirement,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_350) = &input.r#type {
object.key("Type").string(var_350.as_str());
}
if let Some(var_351) = &input.value {
object.key("Value").string(var_351.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ecs_environment_variable(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EcsEnvironmentVariable,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_352) = &input.name {
object.key("name").string(var_352.as_str());
}
if let Some(var_353) = &input.value {
object.key("value").string(var_353.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ecs_environment_file(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EcsEnvironmentFile,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_354) = &input.r#type {
object.key("type").string(var_354.as_str());
}
if let Some(var_355) = &input.value {
object.key("value").string(var_355.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ecs_resource_requirement(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EcsResourceRequirement,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_356) = &input.r#type {
object.key("type").string(var_356.as_str());
}
if let Some(var_357) = &input.value {
object.key("value").string(var_357.as_str());
}
Ok(())
}