pub fn serialize_structure_crate_input_activate_event_source_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ActivateEventSourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.name {
object.key("Name").string(var_1.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_cancel_replay_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CancelReplayInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2) = &input.replay_name {
object.key("ReplayName").string(var_2.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_api_destination_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateApiDestinationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3) = &input.name {
object.key("Name").string(var_3.as_str());
}
if let Some(var_4) = &input.description {
object.key("Description").string(var_4.as_str());
}
if let Some(var_5) = &input.connection_arn {
object.key("ConnectionArn").string(var_5.as_str());
}
if let Some(var_6) = &input.invocation_endpoint {
object.key("InvocationEndpoint").string(var_6.as_str());
}
if let Some(var_7) = &input.http_method {
object.key("HttpMethod").string(var_7.as_str());
}
if let Some(var_8) = &input.invocation_rate_limit_per_second {
object.key("InvocationRateLimitPerSecond").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_8).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_archive_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateArchiveInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_9) = &input.archive_name {
object.key("ArchiveName").string(var_9.as_str());
}
if let Some(var_10) = &input.event_source_arn {
object.key("EventSourceArn").string(var_10.as_str());
}
if let Some(var_11) = &input.description {
object.key("Description").string(var_11.as_str());
}
if let Some(var_12) = &input.event_pattern {
object.key("EventPattern").string(var_12.as_str());
}
if let Some(var_13) = &input.retention_days {
object.key("RetentionDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_13).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_connection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateConnectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_14) = &input.name {
object.key("Name").string(var_14.as_str());
}
if let Some(var_15) = &input.description {
object.key("Description").string(var_15.as_str());
}
if let Some(var_16) = &input.authorization_type {
object.key("AuthorizationType").string(var_16.as_str());
}
if let Some(var_17) = &input.auth_parameters {
#[allow(unused_mut)]
let mut object_18 = object.key("AuthParameters").start_object();
crate::json_ser::serialize_structure_crate_model_create_connection_auth_request_parameters(
&mut object_18,
var_17,
)?;
object_18.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_event_bus_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateEventBusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_19) = &input.name {
object.key("Name").string(var_19.as_str());
}
if let Some(var_20) = &input.event_source_name {
object.key("EventSourceName").string(var_20.as_str());
}
if let Some(var_21) = &input.tags {
let mut array_22 = object.key("Tags").start_array();
for item_23 in var_21 {
{
#[allow(unused_mut)]
let mut object_24 = array_22.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_24, item_23)?;
object_24.finish();
}
}
array_22.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_partner_event_source_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreatePartnerEventSourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_25) = &input.name {
object.key("Name").string(var_25.as_str());
}
if let Some(var_26) = &input.account {
object.key("Account").string(var_26.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_deactivate_event_source_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeactivateEventSourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_27) = &input.name {
object.key("Name").string(var_27.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_deauthorize_connection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeauthorizeConnectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_28) = &input.name {
object.key("Name").string(var_28.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_api_destination_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteApiDestinationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_29) = &input.name {
object.key("Name").string(var_29.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_archive_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteArchiveInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_30) = &input.archive_name {
object.key("ArchiveName").string(var_30.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_connection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteConnectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.name {
object.key("Name").string(var_31.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_event_bus_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteEventBusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_32) = &input.name {
object.key("Name").string(var_32.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_partner_event_source_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeletePartnerEventSourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_33) = &input.name {
object.key("Name").string(var_33.as_str());
}
if let Some(var_34) = &input.account {
object.key("Account").string(var_34.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.name {
object.key("Name").string(var_35.as_str());
}
if let Some(var_36) = &input.event_bus_name {
object.key("EventBusName").string(var_36.as_str());
}
if input.force {
object.key("Force").boolean(input.force);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_api_destination_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeApiDestinationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_37) = &input.name {
object.key("Name").string(var_37.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_archive_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeArchiveInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_38) = &input.archive_name {
object.key("ArchiveName").string(var_38.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_connection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeConnectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_39) = &input.name {
object.key("Name").string(var_39.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_event_bus_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEventBusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_40) = &input.name {
object.key("Name").string(var_40.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_event_source_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEventSourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_41) = &input.name {
object.key("Name").string(var_41.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_partner_event_source_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribePartnerEventSourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_42) = &input.name {
object.key("Name").string(var_42.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_replay_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeReplayInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_43) = &input.replay_name {
object.key("ReplayName").string(var_43.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_44) = &input.name {
object.key("Name").string(var_44.as_str());
}
if let Some(var_45) = &input.event_bus_name {
object.key("EventBusName").string(var_45.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disable_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisableRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_46) = &input.name {
object.key("Name").string(var_46.as_str());
}
if let Some(var_47) = &input.event_bus_name {
object.key("EventBusName").string(var_47.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_enable_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::EnableRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_48) = &input.name {
object.key("Name").string(var_48.as_str());
}
if let Some(var_49) = &input.event_bus_name {
object.key("EventBusName").string(var_49.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_api_destinations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListApiDestinationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.name_prefix {
object.key("NamePrefix").string(var_50.as_str());
}
if let Some(var_51) = &input.connection_arn {
object.key("ConnectionArn").string(var_51.as_str());
}
if let Some(var_52) = &input.next_token {
object.key("NextToken").string(var_52.as_str());
}
if let Some(var_53) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_53).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_archives_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListArchivesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_54) = &input.name_prefix {
object.key("NamePrefix").string(var_54.as_str());
}
if let Some(var_55) = &input.event_source_arn {
object.key("EventSourceArn").string(var_55.as_str());
}
if let Some(var_56) = &input.state {
object.key("State").string(var_56.as_str());
}
if let Some(var_57) = &input.next_token {
object.key("NextToken").string(var_57.as_str());
}
if let Some(var_58) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_58).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_connections_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListConnectionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_59) = &input.name_prefix {
object.key("NamePrefix").string(var_59.as_str());
}
if let Some(var_60) = &input.connection_state {
object.key("ConnectionState").string(var_60.as_str());
}
if let Some(var_61) = &input.next_token {
object.key("NextToken").string(var_61.as_str());
}
if let Some(var_62) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_62).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_event_buses_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListEventBusesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_63) = &input.name_prefix {
object.key("NamePrefix").string(var_63.as_str());
}
if let Some(var_64) = &input.next_token {
object.key("NextToken").string(var_64.as_str());
}
if let Some(var_65) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_65).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_event_sources_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListEventSourcesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_66) = &input.name_prefix {
object.key("NamePrefix").string(var_66.as_str());
}
if let Some(var_67) = &input.next_token {
object.key("NextToken").string(var_67.as_str());
}
if let Some(var_68) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_68).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_partner_event_source_accounts_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPartnerEventSourceAccountsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_69) = &input.event_source_name {
object.key("EventSourceName").string(var_69.as_str());
}
if let Some(var_70) = &input.next_token {
object.key("NextToken").string(var_70.as_str());
}
if let Some(var_71) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_71).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_partner_event_sources_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPartnerEventSourcesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_72) = &input.name_prefix {
object.key("NamePrefix").string(var_72.as_str());
}
if let Some(var_73) = &input.next_token {
object.key("NextToken").string(var_73.as_str());
}
if let Some(var_74) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_74).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_replays_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListReplaysInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_75) = &input.name_prefix {
object.key("NamePrefix").string(var_75.as_str());
}
if let Some(var_76) = &input.state {
object.key("State").string(var_76.as_str());
}
if let Some(var_77) = &input.event_source_arn {
object.key("EventSourceArn").string(var_77.as_str());
}
if let Some(var_78) = &input.next_token {
object.key("NextToken").string(var_78.as_str());
}
if let Some(var_79) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_79).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_rule_names_by_target_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListRuleNamesByTargetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_80) = &input.target_arn {
object.key("TargetArn").string(var_80.as_str());
}
if let Some(var_81) = &input.event_bus_name {
object.key("EventBusName").string(var_81.as_str());
}
if let Some(var_82) = &input.next_token {
object.key("NextToken").string(var_82.as_str());
}
if let Some(var_83) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_83).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_rules_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListRulesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_84) = &input.name_prefix {
object.key("NamePrefix").string(var_84.as_str());
}
if let Some(var_85) = &input.event_bus_name {
object.key("EventBusName").string(var_85.as_str());
}
if let Some(var_86) = &input.next_token {
object.key("NextToken").string(var_86.as_str());
}
if let Some(var_87) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_87).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tags_for_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTagsForResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_88) = &input.resource_arn {
object.key("ResourceARN").string(var_88.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_targets_by_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTargetsByRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.rule {
object.key("Rule").string(var_89.as_str());
}
if let Some(var_90) = &input.event_bus_name {
object.key("EventBusName").string(var_90.as_str());
}
if let Some(var_91) = &input.next_token {
object.key("NextToken").string(var_91.as_str());
}
if let Some(var_92) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_92).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_events_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutEventsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.entries {
let mut array_94 = object.key("Entries").start_array();
for item_95 in var_93 {
{
#[allow(unused_mut)]
let mut object_96 = array_94.value().start_object();
crate::json_ser::serialize_structure_crate_model_put_events_request_entry(
&mut object_96,
item_95,
)?;
object_96.finish();
}
}
array_94.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_partner_events_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutPartnerEventsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_97) = &input.entries {
let mut array_98 = object.key("Entries").start_array();
for item_99 in var_97 {
{
#[allow(unused_mut)]
let mut object_100 = array_98.value().start_object();
crate::json_ser::serialize_structure_crate_model_put_partner_events_request_entry(
&mut object_100,
item_99,
)?;
object_100.finish();
}
}
array_98.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_permission_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutPermissionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_101) = &input.event_bus_name {
object.key("EventBusName").string(var_101.as_str());
}
if let Some(var_102) = &input.action {
object.key("Action").string(var_102.as_str());
}
if let Some(var_103) = &input.principal {
object.key("Principal").string(var_103.as_str());
}
if let Some(var_104) = &input.statement_id {
object.key("StatementId").string(var_104.as_str());
}
if let Some(var_105) = &input.condition {
#[allow(unused_mut)]
let mut object_106 = object.key("Condition").start_object();
crate::json_ser::serialize_structure_crate_model_condition(&mut object_106, var_105)?;
object_106.finish();
}
if let Some(var_107) = &input.policy {
object.key("Policy").string(var_107.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_108) = &input.name {
object.key("Name").string(var_108.as_str());
}
if let Some(var_109) = &input.schedule_expression {
object.key("ScheduleExpression").string(var_109.as_str());
}
if let Some(var_110) = &input.event_pattern {
object.key("EventPattern").string(var_110.as_str());
}
if let Some(var_111) = &input.state {
object.key("State").string(var_111.as_str());
}
if let Some(var_112) = &input.description {
object.key("Description").string(var_112.as_str());
}
if let Some(var_113) = &input.role_arn {
object.key("RoleArn").string(var_113.as_str());
}
if let Some(var_114) = &input.tags {
let mut array_115 = object.key("Tags").start_array();
for item_116 in var_114 {
{
#[allow(unused_mut)]
let mut object_117 = array_115.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_117, item_116)?;
object_117.finish();
}
}
array_115.finish();
}
if let Some(var_118) = &input.event_bus_name {
object.key("EventBusName").string(var_118.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_targets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutTargetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_119) = &input.rule {
object.key("Rule").string(var_119.as_str());
}
if let Some(var_120) = &input.event_bus_name {
object.key("EventBusName").string(var_120.as_str());
}
if let Some(var_121) = &input.targets {
let mut array_122 = object.key("Targets").start_array();
for item_123 in var_121 {
{
#[allow(unused_mut)]
let mut object_124 = array_122.value().start_object();
crate::json_ser::serialize_structure_crate_model_target(&mut object_124, item_123)?;
object_124.finish();
}
}
array_122.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_remove_permission_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RemovePermissionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_125) = &input.statement_id {
object.key("StatementId").string(var_125.as_str());
}
if input.remove_all_permissions {
object
.key("RemoveAllPermissions")
.boolean(input.remove_all_permissions);
}
if let Some(var_126) = &input.event_bus_name {
object.key("EventBusName").string(var_126.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_remove_targets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RemoveTargetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_127) = &input.rule {
object.key("Rule").string(var_127.as_str());
}
if let Some(var_128) = &input.event_bus_name {
object.key("EventBusName").string(var_128.as_str());
}
if let Some(var_129) = &input.ids {
let mut array_130 = object.key("Ids").start_array();
for item_131 in var_129 {
{
array_130.value().string(item_131.as_str());
}
}
array_130.finish();
}
if input.force {
object.key("Force").boolean(input.force);
}
Ok(())
}
pub fn serialize_structure_crate_input_start_replay_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartReplayInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_132) = &input.replay_name {
object.key("ReplayName").string(var_132.as_str());
}
if let Some(var_133) = &input.description {
object.key("Description").string(var_133.as_str());
}
if let Some(var_134) = &input.event_source_arn {
object.key("EventSourceArn").string(var_134.as_str());
}
if let Some(var_135) = &input.event_start_time {
object
.key("EventStartTime")
.date_time(var_135, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_136) = &input.event_end_time {
object
.key("EventEndTime")
.date_time(var_136, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_137) = &input.destination {
#[allow(unused_mut)]
let mut object_138 = object.key("Destination").start_object();
crate::json_ser::serialize_structure_crate_model_replay_destination(
&mut object_138,
var_137,
)?;
object_138.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_139) = &input.resource_arn {
object.key("ResourceARN").string(var_139.as_str());
}
if let Some(var_140) = &input.tags {
let mut array_141 = object.key("Tags").start_array();
for item_142 in var_140 {
{
#[allow(unused_mut)]
let mut object_143 = array_141.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_143, item_142)?;
object_143.finish();
}
}
array_141.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_test_event_pattern_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TestEventPatternInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_144) = &input.event_pattern {
object.key("EventPattern").string(var_144.as_str());
}
if let Some(var_145) = &input.event {
object.key("Event").string(var_145.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_untag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UntagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.resource_arn {
object.key("ResourceARN").string(var_146.as_str());
}
if let Some(var_147) = &input.tag_keys {
let mut array_148 = object.key("TagKeys").start_array();
for item_149 in var_147 {
{
array_148.value().string(item_149.as_str());
}
}
array_148.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_api_destination_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateApiDestinationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_150) = &input.name {
object.key("Name").string(var_150.as_str());
}
if let Some(var_151) = &input.description {
object.key("Description").string(var_151.as_str());
}
if let Some(var_152) = &input.connection_arn {
object.key("ConnectionArn").string(var_152.as_str());
}
if let Some(var_153) = &input.invocation_endpoint {
object.key("InvocationEndpoint").string(var_153.as_str());
}
if let Some(var_154) = &input.http_method {
object.key("HttpMethod").string(var_154.as_str());
}
if let Some(var_155) = &input.invocation_rate_limit_per_second {
object.key("InvocationRateLimitPerSecond").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_155).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_archive_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateArchiveInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_156) = &input.archive_name {
object.key("ArchiveName").string(var_156.as_str());
}
if let Some(var_157) = &input.description {
object.key("Description").string(var_157.as_str());
}
if let Some(var_158) = &input.event_pattern {
object.key("EventPattern").string(var_158.as_str());
}
if let Some(var_159) = &input.retention_days {
object.key("RetentionDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_159).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_connection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateConnectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_160) = &input.name {
object.key("Name").string(var_160.as_str());
}
if let Some(var_161) = &input.description {
object.key("Description").string(var_161.as_str());
}
if let Some(var_162) = &input.authorization_type {
object.key("AuthorizationType").string(var_162.as_str());
}
if let Some(var_163) = &input.auth_parameters {
#[allow(unused_mut)]
let mut object_164 = object.key("AuthParameters").start_object();
crate::json_ser::serialize_structure_crate_model_update_connection_auth_request_parameters(
&mut object_164,
var_163,
)?;
object_164.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_create_connection_auth_request_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateConnectionAuthRequestParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_165) = &input.basic_auth_parameters {
#[allow(unused_mut)]
let mut object_166 = object.key("BasicAuthParameters").start_object();
crate::json_ser::serialize_structure_crate_model_create_connection_basic_auth_request_parameters(&mut object_166, var_165)?;
object_166.finish();
}
if let Some(var_167) = &input.o_auth_parameters {
#[allow(unused_mut)]
let mut object_168 = object.key("OAuthParameters").start_object();
crate::json_ser::serialize_structure_crate_model_create_connection_o_auth_request_parameters(&mut object_168, var_167)?;
object_168.finish();
}
if let Some(var_169) = &input.api_key_auth_parameters {
#[allow(unused_mut)]
let mut object_170 = object.key("ApiKeyAuthParameters").start_object();
crate::json_ser::serialize_structure_crate_model_create_connection_api_key_auth_request_parameters(&mut object_170, var_169)?;
object_170.finish();
}
if let Some(var_171) = &input.invocation_http_parameters {
#[allow(unused_mut)]
let mut object_172 = object.key("InvocationHttpParameters").start_object();
crate::json_ser::serialize_structure_crate_model_connection_http_parameters(
&mut object_172,
var_171,
)?;
object_172.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_173) = &input.key {
object.key("Key").string(var_173.as_str());
}
if let Some(var_174) = &input.value {
object.key("Value").string(var_174.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_put_events_request_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PutEventsRequestEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_175) = &input.time {
object
.key("Time")
.date_time(var_175, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_176) = &input.source {
object.key("Source").string(var_176.as_str());
}
if let Some(var_177) = &input.resources {
let mut array_178 = object.key("Resources").start_array();
for item_179 in var_177 {
{
array_178.value().string(item_179.as_str());
}
}
array_178.finish();
}
if let Some(var_180) = &input.detail_type {
object.key("DetailType").string(var_180.as_str());
}
if let Some(var_181) = &input.detail {
object.key("Detail").string(var_181.as_str());
}
if let Some(var_182) = &input.event_bus_name {
object.key("EventBusName").string(var_182.as_str());
}
if let Some(var_183) = &input.trace_header {
object.key("TraceHeader").string(var_183.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_put_partner_events_request_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PutPartnerEventsRequestEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_184) = &input.time {
object
.key("Time")
.date_time(var_184, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_185) = &input.source {
object.key("Source").string(var_185.as_str());
}
if let Some(var_186) = &input.resources {
let mut array_187 = object.key("Resources").start_array();
for item_188 in var_186 {
{
array_187.value().string(item_188.as_str());
}
}
array_187.finish();
}
if let Some(var_189) = &input.detail_type {
object.key("DetailType").string(var_189.as_str());
}
if let Some(var_190) = &input.detail {
object.key("Detail").string(var_190.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Condition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_191) = &input.r#type {
object.key("Type").string(var_191.as_str());
}
if let Some(var_192) = &input.key {
object.key("Key").string(var_192.as_str());
}
if let Some(var_193) = &input.value {
object.key("Value").string(var_193.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_target(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Target,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_194) = &input.id {
object.key("Id").string(var_194.as_str());
}
if let Some(var_195) = &input.arn {
object.key("Arn").string(var_195.as_str());
}
if let Some(var_196) = &input.role_arn {
object.key("RoleArn").string(var_196.as_str());
}
if let Some(var_197) = &input.input {
object.key("Input").string(var_197.as_str());
}
if let Some(var_198) = &input.input_path {
object.key("InputPath").string(var_198.as_str());
}
if let Some(var_199) = &input.input_transformer {
#[allow(unused_mut)]
let mut object_200 = object.key("InputTransformer").start_object();
crate::json_ser::serialize_structure_crate_model_input_transformer(
&mut object_200,
var_199,
)?;
object_200.finish();
}
if let Some(var_201) = &input.kinesis_parameters {
#[allow(unused_mut)]
let mut object_202 = object.key("KinesisParameters").start_object();
crate::json_ser::serialize_structure_crate_model_kinesis_parameters(
&mut object_202,
var_201,
)?;
object_202.finish();
}
if let Some(var_203) = &input.run_command_parameters {
#[allow(unused_mut)]
let mut object_204 = object.key("RunCommandParameters").start_object();
crate::json_ser::serialize_structure_crate_model_run_command_parameters(
&mut object_204,
var_203,
)?;
object_204.finish();
}
if let Some(var_205) = &input.ecs_parameters {
#[allow(unused_mut)]
let mut object_206 = object.key("EcsParameters").start_object();
crate::json_ser::serialize_structure_crate_model_ecs_parameters(&mut object_206, var_205)?;
object_206.finish();
}
if let Some(var_207) = &input.batch_parameters {
#[allow(unused_mut)]
let mut object_208 = object.key("BatchParameters").start_object();
crate::json_ser::serialize_structure_crate_model_batch_parameters(
&mut object_208,
var_207,
)?;
object_208.finish();
}
if let Some(var_209) = &input.sqs_parameters {
#[allow(unused_mut)]
let mut object_210 = object.key("SqsParameters").start_object();
crate::json_ser::serialize_structure_crate_model_sqs_parameters(&mut object_210, var_209)?;
object_210.finish();
}
if let Some(var_211) = &input.http_parameters {
#[allow(unused_mut)]
let mut object_212 = object.key("HttpParameters").start_object();
crate::json_ser::serialize_structure_crate_model_http_parameters(&mut object_212, var_211)?;
object_212.finish();
}
if let Some(var_213) = &input.redshift_data_parameters {
#[allow(unused_mut)]
let mut object_214 = object.key("RedshiftDataParameters").start_object();
crate::json_ser::serialize_structure_crate_model_redshift_data_parameters(
&mut object_214,
var_213,
)?;
object_214.finish();
}
if let Some(var_215) = &input.sage_maker_pipeline_parameters {
#[allow(unused_mut)]
let mut object_216 = object.key("SageMakerPipelineParameters").start_object();
crate::json_ser::serialize_structure_crate_model_sage_maker_pipeline_parameters(
&mut object_216,
var_215,
)?;
object_216.finish();
}
if let Some(var_217) = &input.dead_letter_config {
#[allow(unused_mut)]
let mut object_218 = object.key("DeadLetterConfig").start_object();
crate::json_ser::serialize_structure_crate_model_dead_letter_config(
&mut object_218,
var_217,
)?;
object_218.finish();
}
if let Some(var_219) = &input.retry_policy {
#[allow(unused_mut)]
let mut object_220 = object.key("RetryPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_retry_policy(&mut object_220, var_219)?;
object_220.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_replay_destination(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReplayDestination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_221) = &input.arn {
object.key("Arn").string(var_221.as_str());
}
if let Some(var_222) = &input.filter_arns {
let mut array_223 = object.key("FilterArns").start_array();
for item_224 in var_222 {
{
array_223.value().string(item_224.as_str());
}
}
array_223.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_connection_auth_request_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateConnectionAuthRequestParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_225) = &input.basic_auth_parameters {
#[allow(unused_mut)]
let mut object_226 = object.key("BasicAuthParameters").start_object();
crate::json_ser::serialize_structure_crate_model_update_connection_basic_auth_request_parameters(&mut object_226, var_225)?;
object_226.finish();
}
if let Some(var_227) = &input.o_auth_parameters {
#[allow(unused_mut)]
let mut object_228 = object.key("OAuthParameters").start_object();
crate::json_ser::serialize_structure_crate_model_update_connection_o_auth_request_parameters(&mut object_228, var_227)?;
object_228.finish();
}
if let Some(var_229) = &input.api_key_auth_parameters {
#[allow(unused_mut)]
let mut object_230 = object.key("ApiKeyAuthParameters").start_object();
crate::json_ser::serialize_structure_crate_model_update_connection_api_key_auth_request_parameters(&mut object_230, var_229)?;
object_230.finish();
}
if let Some(var_231) = &input.invocation_http_parameters {
#[allow(unused_mut)]
let mut object_232 = object.key("InvocationHttpParameters").start_object();
crate::json_ser::serialize_structure_crate_model_connection_http_parameters(
&mut object_232,
var_231,
)?;
object_232.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_create_connection_basic_auth_request_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateConnectionBasicAuthRequestParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_233) = &input.username {
object.key("Username").string(var_233.as_str());
}
if let Some(var_234) = &input.password {
object.key("Password").string(var_234.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_create_connection_o_auth_request_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateConnectionOAuthRequestParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_235) = &input.client_parameters {
#[allow(unused_mut)]
let mut object_236 = object.key("ClientParameters").start_object();
crate::json_ser::serialize_structure_crate_model_create_connection_o_auth_client_request_parameters(&mut object_236, var_235)?;
object_236.finish();
}
if let Some(var_237) = &input.authorization_endpoint {
object.key("AuthorizationEndpoint").string(var_237.as_str());
}
if let Some(var_238) = &input.http_method {
object.key("HttpMethod").string(var_238.as_str());
}
if let Some(var_239) = &input.o_auth_http_parameters {
#[allow(unused_mut)]
let mut object_240 = object.key("OAuthHttpParameters").start_object();
crate::json_ser::serialize_structure_crate_model_connection_http_parameters(
&mut object_240,
var_239,
)?;
object_240.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_create_connection_api_key_auth_request_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateConnectionApiKeyAuthRequestParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_241) = &input.api_key_name {
object.key("ApiKeyName").string(var_241.as_str());
}
if let Some(var_242) = &input.api_key_value {
object.key("ApiKeyValue").string(var_242.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_connection_http_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConnectionHttpParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_243) = &input.header_parameters {
let mut array_244 = object.key("HeaderParameters").start_array();
for item_245 in var_243 {
{
#[allow(unused_mut)]
let mut object_246 = array_244.value().start_object();
crate::json_ser::serialize_structure_crate_model_connection_header_parameter(
&mut object_246,
item_245,
)?;
object_246.finish();
}
}
array_244.finish();
}
if let Some(var_247) = &input.query_string_parameters {
let mut array_248 = object.key("QueryStringParameters").start_array();
for item_249 in var_247 {
{
#[allow(unused_mut)]
let mut object_250 = array_248.value().start_object();
crate::json_ser::serialize_structure_crate_model_connection_query_string_parameter(
&mut object_250,
item_249,
)?;
object_250.finish();
}
}
array_248.finish();
}
if let Some(var_251) = &input.body_parameters {
let mut array_252 = object.key("BodyParameters").start_array();
for item_253 in var_251 {
{
#[allow(unused_mut)]
let mut object_254 = array_252.value().start_object();
crate::json_ser::serialize_structure_crate_model_connection_body_parameter(
&mut object_254,
item_253,
)?;
object_254.finish();
}
}
array_252.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_input_transformer(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InputTransformer,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_255) = &input.input_paths_map {
#[allow(unused_mut)]
let mut object_256 = object.key("InputPathsMap").start_object();
for (key_257, value_258) in var_255 {
{
object_256.key(key_257.as_str()).string(value_258.as_str());
}
}
object_256.finish();
}
if let Some(var_259) = &input.input_template {
object.key("InputTemplate").string(var_259.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_kinesis_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KinesisParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_260) = &input.partition_key_path {
object.key("PartitionKeyPath").string(var_260.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_run_command_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RunCommandParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_261) = &input.run_command_targets {
let mut array_262 = object.key("RunCommandTargets").start_array();
for item_263 in var_261 {
{
#[allow(unused_mut)]
let mut object_264 = array_262.value().start_object();
crate::json_ser::serialize_structure_crate_model_run_command_target(
&mut object_264,
item_263,
)?;
object_264.finish();
}
}
array_262.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_ecs_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EcsParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_265) = &input.task_definition_arn {
object.key("TaskDefinitionArn").string(var_265.as_str());
}
if let Some(var_266) = &input.task_count {
object.key("TaskCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_266).into()),
);
}
if let Some(var_267) = &input.launch_type {
object.key("LaunchType").string(var_267.as_str());
}
if let Some(var_268) = &input.network_configuration {
#[allow(unused_mut)]
let mut object_269 = object.key("NetworkConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_network_configuration(
&mut object_269,
var_268,
)?;
object_269.finish();
}
if let Some(var_270) = &input.platform_version {
object.key("PlatformVersion").string(var_270.as_str());
}
if let Some(var_271) = &input.group {
object.key("Group").string(var_271.as_str());
}
if let Some(var_272) = &input.capacity_provider_strategy {
let mut array_273 = object.key("CapacityProviderStrategy").start_array();
for item_274 in var_272 {
{
#[allow(unused_mut)]
let mut object_275 = array_273.value().start_object();
crate::json_ser::serialize_structure_crate_model_capacity_provider_strategy_item(
&mut object_275,
item_274,
)?;
object_275.finish();
}
}
array_273.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_276) = &input.placement_constraints {
let mut array_277 = object.key("PlacementConstraints").start_array();
for item_278 in var_276 {
{
#[allow(unused_mut)]
let mut object_279 = array_277.value().start_object();
crate::json_ser::serialize_structure_crate_model_placement_constraint(
&mut object_279,
item_278,
)?;
object_279.finish();
}
}
array_277.finish();
}
if let Some(var_280) = &input.placement_strategy {
let mut array_281 = object.key("PlacementStrategy").start_array();
for item_282 in var_280 {
{
#[allow(unused_mut)]
let mut object_283 = array_281.value().start_object();
crate::json_ser::serialize_structure_crate_model_placement_strategy(
&mut object_283,
item_282,
)?;
object_283.finish();
}
}
array_281.finish();
}
if let Some(var_284) = &input.propagate_tags {
object.key("PropagateTags").string(var_284.as_str());
}
if let Some(var_285) = &input.reference_id {
object.key("ReferenceId").string(var_285.as_str());
}
if let Some(var_286) = &input.tags {
let mut array_287 = object.key("Tags").start_array();
for item_288 in var_286 {
{
#[allow(unused_mut)]
let mut object_289 = array_287.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_289, item_288)?;
object_289.finish();
}
}
array_287.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_batch_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BatchParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_290) = &input.job_definition {
object.key("JobDefinition").string(var_290.as_str());
}
if let Some(var_291) = &input.job_name {
object.key("JobName").string(var_291.as_str());
}
if let Some(var_292) = &input.array_properties {
#[allow(unused_mut)]
let mut object_293 = object.key("ArrayProperties").start_object();
crate::json_ser::serialize_structure_crate_model_batch_array_properties(
&mut object_293,
var_292,
)?;
object_293.finish();
}
if let Some(var_294) = &input.retry_strategy {
#[allow(unused_mut)]
let mut object_295 = object.key("RetryStrategy").start_object();
crate::json_ser::serialize_structure_crate_model_batch_retry_strategy(
&mut object_295,
var_294,
)?;
object_295.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sqs_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SqsParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_296) = &input.message_group_id {
object.key("MessageGroupId").string(var_296.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_http_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HttpParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_297) = &input.path_parameter_values {
let mut array_298 = object.key("PathParameterValues").start_array();
for item_299 in var_297 {
{
array_298.value().string(item_299.as_str());
}
}
array_298.finish();
}
if let Some(var_300) = &input.header_parameters {
#[allow(unused_mut)]
let mut object_301 = object.key("HeaderParameters").start_object();
for (key_302, value_303) in var_300 {
{
object_301.key(key_302.as_str()).string(value_303.as_str());
}
}
object_301.finish();
}
if let Some(var_304) = &input.query_string_parameters {
#[allow(unused_mut)]
let mut object_305 = object.key("QueryStringParameters").start_object();
for (key_306, value_307) in var_304 {
{
object_305.key(key_306.as_str()).string(value_307.as_str());
}
}
object_305.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_redshift_data_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RedshiftDataParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_308) = &input.secret_manager_arn {
object.key("SecretManagerArn").string(var_308.as_str());
}
if let Some(var_309) = &input.database {
object.key("Database").string(var_309.as_str());
}
if let Some(var_310) = &input.db_user {
object.key("DbUser").string(var_310.as_str());
}
if let Some(var_311) = &input.sql {
object.key("Sql").string(var_311.as_str());
}
if let Some(var_312) = &input.statement_name {
object.key("StatementName").string(var_312.as_str());
}
if input.with_event {
object.key("WithEvent").boolean(input.with_event);
}
Ok(())
}
pub fn serialize_structure_crate_model_sage_maker_pipeline_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SageMakerPipelineParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_313) = &input.pipeline_parameter_list {
let mut array_314 = object.key("PipelineParameterList").start_array();
for item_315 in var_313 {
{
#[allow(unused_mut)]
let mut object_316 = array_314.value().start_object();
crate::json_ser::serialize_structure_crate_model_sage_maker_pipeline_parameter(
&mut object_316,
item_315,
)?;
object_316.finish();
}
}
array_314.finish();
}
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_317) = &input.arn {
object.key("Arn").string(var_317.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_retry_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RetryPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_318) = &input.maximum_retry_attempts {
object.key("MaximumRetryAttempts").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_318).into()),
);
}
if let Some(var_319) = &input.maximum_event_age_in_seconds {
object.key("MaximumEventAgeInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_319).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_update_connection_basic_auth_request_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateConnectionBasicAuthRequestParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_320) = &input.username {
object.key("Username").string(var_320.as_str());
}
if let Some(var_321) = &input.password {
object.key("Password").string(var_321.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update_connection_o_auth_request_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateConnectionOAuthRequestParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_322) = &input.client_parameters {
#[allow(unused_mut)]
let mut object_323 = object.key("ClientParameters").start_object();
crate::json_ser::serialize_structure_crate_model_update_connection_o_auth_client_request_parameters(&mut object_323, var_322)?;
object_323.finish();
}
if let Some(var_324) = &input.authorization_endpoint {
object.key("AuthorizationEndpoint").string(var_324.as_str());
}
if let Some(var_325) = &input.http_method {
object.key("HttpMethod").string(var_325.as_str());
}
if let Some(var_326) = &input.o_auth_http_parameters {
#[allow(unused_mut)]
let mut object_327 = object.key("OAuthHttpParameters").start_object();
crate::json_ser::serialize_structure_crate_model_connection_http_parameters(
&mut object_327,
var_326,
)?;
object_327.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_connection_api_key_auth_request_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateConnectionApiKeyAuthRequestParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_328) = &input.api_key_name {
object.key("ApiKeyName").string(var_328.as_str());
}
if let Some(var_329) = &input.api_key_value {
object.key("ApiKeyValue").string(var_329.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_create_connection_o_auth_client_request_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateConnectionOAuthClientRequestParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_330) = &input.client_id {
object.key("ClientID").string(var_330.as_str());
}
if let Some(var_331) = &input.client_secret {
object.key("ClientSecret").string(var_331.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_connection_header_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConnectionHeaderParameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_332) = &input.key {
object.key("Key").string(var_332.as_str());
}
if let Some(var_333) = &input.value {
object.key("Value").string(var_333.as_str());
}
if input.is_value_secret {
object.key("IsValueSecret").boolean(input.is_value_secret);
}
Ok(())
}
pub fn serialize_structure_crate_model_connection_query_string_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConnectionQueryStringParameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_334) = &input.key {
object.key("Key").string(var_334.as_str());
}
if let Some(var_335) = &input.value {
object.key("Value").string(var_335.as_str());
}
if input.is_value_secret {
object.key("IsValueSecret").boolean(input.is_value_secret);
}
Ok(())
}
pub fn serialize_structure_crate_model_connection_body_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConnectionBodyParameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_336) = &input.key {
object.key("Key").string(var_336.as_str());
}
if let Some(var_337) = &input.value {
object.key("Value").string(var_337.as_str());
}
if input.is_value_secret {
object.key("IsValueSecret").boolean(input.is_value_secret);
}
Ok(())
}
pub fn serialize_structure_crate_model_run_command_target(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RunCommandTarget,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_338) = &input.key {
object.key("Key").string(var_338.as_str());
}
if let Some(var_339) = &input.values {
let mut array_340 = object.key("Values").start_array();
for item_341 in var_339 {
{
array_340.value().string(item_341.as_str());
}
}
array_340.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_342) = &input.awsvpc_configuration {
#[allow(unused_mut)]
let mut object_343 = object.key("awsvpcConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_aws_vpc_configuration(
&mut object_343,
var_342,
)?;
object_343.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_344) = &input.capacity_provider {
object.key("capacityProvider").string(var_344.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_345) = &input.r#type {
object.key("type").string(var_345.as_str());
}
if let Some(var_346) = &input.expression {
object.key("expression").string(var_346.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_347) = &input.r#type {
object.key("type").string(var_347.as_str());
}
if let Some(var_348) = &input.field {
object.key("field").string(var_348.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_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_349) = &input.name {
object.key("Name").string(var_349.as_str());
}
if let Some(var_350) = &input.value {
object.key("Value").string(var_350.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update_connection_o_auth_client_request_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateConnectionOAuthClientRequestParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_351) = &input.client_id {
object.key("ClientID").string(var_351.as_str());
}
if let Some(var_352) = &input.client_secret {
object.key("ClientSecret").string(var_352.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_353) = &input.subnets {
let mut array_354 = object.key("Subnets").start_array();
for item_355 in var_353 {
{
array_354.value().string(item_355.as_str());
}
}
array_354.finish();
}
if let Some(var_356) = &input.security_groups {
let mut array_357 = object.key("SecurityGroups").start_array();
for item_358 in var_356 {
{
array_357.value().string(item_358.as_str());
}
}
array_357.finish();
}
if let Some(var_359) = &input.assign_public_ip {
object.key("AssignPublicIp").string(var_359.as_str());
}
Ok(())
}