pub fn serialize_structure_crate_input_create_replication_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateReplicationSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.client_token {
object.key("clientToken").string(var_1.as_str());
}
if let Some(var_2) = &input.regions {
#[allow(unused_mut)]
let mut object_3 = object.key("regions").start_object();
for (key_4, value_5) in var_2 {
{
#[allow(unused_mut)]
let mut object_6 = object_3.key(key_4.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_region_map_input_value(
&mut object_6,
value_5,
)?;
object_6.finish();
}
}
object_3.finish();
}
if let Some(var_7) = &input.tags {
#[allow(unused_mut)]
let mut object_8 = object.key("tags").start_object();
for (key_9, value_10) in var_7 {
{
object_8.key(key_9.as_str()).string(value_10.as_str());
}
}
object_8.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_response_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateResponsePlanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_11) = &input.actions {
let mut array_12 = object.key("actions").start_array();
for item_13 in var_11 {
{
#[allow(unused_mut)]
let mut object_14 = array_12.value().start_object();
crate::json_ser::serialize_union_crate_model_action(&mut object_14, item_13)?;
object_14.finish();
}
}
array_12.finish();
}
if let Some(var_15) = &input.chat_channel {
#[allow(unused_mut)]
let mut object_16 = object.key("chatChannel").start_object();
crate::json_ser::serialize_union_crate_model_chat_channel(&mut object_16, var_15)?;
object_16.finish();
}
if let Some(var_17) = &input.client_token {
object.key("clientToken").string(var_17.as_str());
}
if let Some(var_18) = &input.display_name {
object.key("displayName").string(var_18.as_str());
}
if let Some(var_19) = &input.engagements {
let mut array_20 = object.key("engagements").start_array();
for item_21 in var_19 {
{
array_20.value().string(item_21.as_str());
}
}
array_20.finish();
}
if let Some(var_22) = &input.incident_template {
#[allow(unused_mut)]
let mut object_23 = object.key("incidentTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_incident_template(&mut object_23, var_22)?;
object_23.finish();
}
if let Some(var_24) = &input.integrations {
let mut array_25 = object.key("integrations").start_array();
for item_26 in var_24 {
{
#[allow(unused_mut)]
let mut object_27 = array_25.value().start_object();
crate::json_ser::serialize_union_crate_model_integration(&mut object_27, item_26)?;
object_27.finish();
}
}
array_25.finish();
}
if let Some(var_28) = &input.name {
object.key("name").string(var_28.as_str());
}
if let Some(var_29) = &input.tags {
#[allow(unused_mut)]
let mut object_30 = object.key("tags").start_object();
for (key_31, value_32) in var_29 {
{
object_30.key(key_31.as_str()).string(value_32.as_str());
}
}
object_30.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_timeline_event_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTimelineEventInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_33) = &input.client_token {
object.key("clientToken").string(var_33.as_str());
}
if let Some(var_34) = &input.event_data {
object.key("eventData").string(var_34.as_str());
}
if let Some(var_35) = &input.event_references {
let mut array_36 = object.key("eventReferences").start_array();
for item_37 in var_35 {
{
#[allow(unused_mut)]
let mut object_38 = array_36.value().start_object();
crate::json_ser::serialize_union_crate_model_event_reference(
&mut object_38,
item_37,
)?;
object_38.finish();
}
}
array_36.finish();
}
if let Some(var_39) = &input.event_time {
object
.key("eventTime")
.date_time(var_39, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_40) = &input.event_type {
object.key("eventType").string(var_40.as_str());
}
if let Some(var_41) = &input.incident_record_arn {
object.key("incidentRecordArn").string(var_41.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_incident_record_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteIncidentRecordInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_42) = &input.arn {
object.key("arn").string(var_42.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_resource_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteResourcePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_43) = &input.policy_id {
object.key("policyId").string(var_43.as_str());
}
if let Some(var_44) = &input.resource_arn {
object.key("resourceArn").string(var_44.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_response_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteResponsePlanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_45) = &input.arn {
object.key("arn").string(var_45.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_timeline_event_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteTimelineEventInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_46) = &input.event_id {
object.key("eventId").string(var_46.as_str());
}
if let Some(var_47) = &input.incident_record_arn {
object.key("incidentRecordArn").string(var_47.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_resource_policies_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetResourcePoliciesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_48) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_48).into()),
);
}
if let Some(var_49) = &input.next_token {
object.key("nextToken").string(var_49.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_incident_records_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListIncidentRecordsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.filters {
let mut array_51 = object.key("filters").start_array();
for item_52 in var_50 {
{
#[allow(unused_mut)]
let mut object_53 = array_51.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_53, item_52)?;
object_53.finish();
}
}
array_51.finish();
}
if let Some(var_54) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_54).into()),
);
}
if let Some(var_55) = &input.next_token {
object.key("nextToken").string(var_55.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_related_items_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListRelatedItemsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_56) = &input.incident_record_arn {
object.key("incidentRecordArn").string(var_56.as_str());
}
if let Some(var_57) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_57).into()),
);
}
if let Some(var_58) = &input.next_token {
object.key("nextToken").string(var_58.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_replication_sets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListReplicationSetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_59) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_59).into()),
);
}
if let Some(var_60) = &input.next_token {
object.key("nextToken").string(var_60.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_response_plans_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListResponsePlansInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_61) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_61).into()),
);
}
if let Some(var_62) = &input.next_token {
object.key("nextToken").string(var_62.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_timeline_events_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTimelineEventsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_63) = &input.filters {
let mut array_64 = object.key("filters").start_array();
for item_65 in var_63 {
{
#[allow(unused_mut)]
let mut object_66 = array_64.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_66, item_65)?;
object_66.finish();
}
}
array_64.finish();
}
if let Some(var_67) = &input.incident_record_arn {
object.key("incidentRecordArn").string(var_67.as_str());
}
if let Some(var_68) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_68).into()),
);
}
if let Some(var_69) = &input.next_token {
object.key("nextToken").string(var_69.as_str());
}
if let Some(var_70) = &input.sort_by {
object.key("sortBy").string(var_70.as_str());
}
if let Some(var_71) = &input.sort_order {
object.key("sortOrder").string(var_71.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_resource_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutResourcePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_72) = &input.policy {
object.key("policy").string(var_72.as_str());
}
if let Some(var_73) = &input.resource_arn {
object.key("resourceArn").string(var_73.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_incident_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartIncidentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_74) = &input.client_token {
object.key("clientToken").string(var_74.as_str());
}
if let Some(var_75) = &input.impact {
object.key("impact").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_75).into()),
);
}
if let Some(var_76) = &input.related_items {
let mut array_77 = object.key("relatedItems").start_array();
for item_78 in var_76 {
{
#[allow(unused_mut)]
let mut object_79 = array_77.value().start_object();
crate::json_ser::serialize_structure_crate_model_related_item(
&mut object_79,
item_78,
)?;
object_79.finish();
}
}
array_77.finish();
}
if let Some(var_80) = &input.response_plan_arn {
object.key("responsePlanArn").string(var_80.as_str());
}
if let Some(var_81) = &input.title {
object.key("title").string(var_81.as_str());
}
if let Some(var_82) = &input.trigger_details {
#[allow(unused_mut)]
let mut object_83 = object.key("triggerDetails").start_object();
crate::json_ser::serialize_structure_crate_model_trigger_details(&mut object_83, var_82)?;
object_83.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_84) = &input.tags {
#[allow(unused_mut)]
let mut object_85 = object.key("tags").start_object();
for (key_86, value_87) in var_84 {
{
object_85.key(key_86.as_str()).string(value_87.as_str());
}
}
object_85.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_deletion_protection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDeletionProtectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_88) = &input.arn {
object.key("arn").string(var_88.as_str());
}
if let Some(var_89) = &input.client_token {
object.key("clientToken").string(var_89.as_str());
}
if let Some(var_90) = &input.deletion_protected {
object.key("deletionProtected").boolean(*var_90);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_incident_record_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateIncidentRecordInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_91) = &input.arn {
object.key("arn").string(var_91.as_str());
}
if let Some(var_92) = &input.chat_channel {
#[allow(unused_mut)]
let mut object_93 = object.key("chatChannel").start_object();
crate::json_ser::serialize_union_crate_model_chat_channel(&mut object_93, var_92)?;
object_93.finish();
}
if let Some(var_94) = &input.client_token {
object.key("clientToken").string(var_94.as_str());
}
if let Some(var_95) = &input.impact {
object.key("impact").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_95).into()),
);
}
if let Some(var_96) = &input.notification_targets {
let mut array_97 = object.key("notificationTargets").start_array();
for item_98 in var_96 {
{
#[allow(unused_mut)]
let mut object_99 = array_97.value().start_object();
crate::json_ser::serialize_union_crate_model_notification_target_item(
&mut object_99,
item_98,
)?;
object_99.finish();
}
}
array_97.finish();
}
if let Some(var_100) = &input.status {
object.key("status").string(var_100.as_str());
}
if let Some(var_101) = &input.summary {
object.key("summary").string(var_101.as_str());
}
if let Some(var_102) = &input.title {
object.key("title").string(var_102.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_related_items_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRelatedItemsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_103) = &input.client_token {
object.key("clientToken").string(var_103.as_str());
}
if let Some(var_104) = &input.incident_record_arn {
object.key("incidentRecordArn").string(var_104.as_str());
}
if let Some(var_105) = &input.related_items_update {
#[allow(unused_mut)]
let mut object_106 = object.key("relatedItemsUpdate").start_object();
crate::json_ser::serialize_union_crate_model_related_items_update(
&mut object_106,
var_105,
)?;
object_106.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_replication_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateReplicationSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_107) = &input.actions {
let mut array_108 = object.key("actions").start_array();
for item_109 in var_107 {
{
#[allow(unused_mut)]
let mut object_110 = array_108.value().start_object();
crate::json_ser::serialize_union_crate_model_update_replication_set_action(
&mut object_110,
item_109,
)?;
object_110.finish();
}
}
array_108.finish();
}
if let Some(var_111) = &input.arn {
object.key("arn").string(var_111.as_str());
}
if let Some(var_112) = &input.client_token {
object.key("clientToken").string(var_112.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_response_plan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateResponsePlanInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_113) = &input.actions {
let mut array_114 = object.key("actions").start_array();
for item_115 in var_113 {
{
#[allow(unused_mut)]
let mut object_116 = array_114.value().start_object();
crate::json_ser::serialize_union_crate_model_action(&mut object_116, item_115)?;
object_116.finish();
}
}
array_114.finish();
}
if let Some(var_117) = &input.arn {
object.key("arn").string(var_117.as_str());
}
if let Some(var_118) = &input.chat_channel {
#[allow(unused_mut)]
let mut object_119 = object.key("chatChannel").start_object();
crate::json_ser::serialize_union_crate_model_chat_channel(&mut object_119, var_118)?;
object_119.finish();
}
if let Some(var_120) = &input.client_token {
object.key("clientToken").string(var_120.as_str());
}
if let Some(var_121) = &input.display_name {
object.key("displayName").string(var_121.as_str());
}
if let Some(var_122) = &input.engagements {
let mut array_123 = object.key("engagements").start_array();
for item_124 in var_122 {
{
array_123.value().string(item_124.as_str());
}
}
array_123.finish();
}
if let Some(var_125) = &input.incident_template_dedupe_string {
object
.key("incidentTemplateDedupeString")
.string(var_125.as_str());
}
if let Some(var_126) = &input.incident_template_impact {
object.key("incidentTemplateImpact").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_126).into()),
);
}
if let Some(var_127) = &input.incident_template_notification_targets {
let mut array_128 = object
.key("incidentTemplateNotificationTargets")
.start_array();
for item_129 in var_127 {
{
#[allow(unused_mut)]
let mut object_130 = array_128.value().start_object();
crate::json_ser::serialize_union_crate_model_notification_target_item(
&mut object_130,
item_129,
)?;
object_130.finish();
}
}
array_128.finish();
}
if let Some(var_131) = &input.incident_template_summary {
object
.key("incidentTemplateSummary")
.string(var_131.as_str());
}
if let Some(var_132) = &input.incident_template_tags {
#[allow(unused_mut)]
let mut object_133 = object.key("incidentTemplateTags").start_object();
for (key_134, value_135) in var_132 {
{
object_133.key(key_134.as_str()).string(value_135.as_str());
}
}
object_133.finish();
}
if let Some(var_136) = &input.incident_template_title {
object.key("incidentTemplateTitle").string(var_136.as_str());
}
if let Some(var_137) = &input.integrations {
let mut array_138 = object.key("integrations").start_array();
for item_139 in var_137 {
{
#[allow(unused_mut)]
let mut object_140 = array_138.value().start_object();
crate::json_ser::serialize_union_crate_model_integration(
&mut object_140,
item_139,
)?;
object_140.finish();
}
}
array_138.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_timeline_event_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateTimelineEventInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_141) = &input.client_token {
object.key("clientToken").string(var_141.as_str());
}
if let Some(var_142) = &input.event_data {
object.key("eventData").string(var_142.as_str());
}
if let Some(var_143) = &input.event_id {
object.key("eventId").string(var_143.as_str());
}
if let Some(var_144) = &input.event_references {
let mut array_145 = object.key("eventReferences").start_array();
for item_146 in var_144 {
{
#[allow(unused_mut)]
let mut object_147 = array_145.value().start_object();
crate::json_ser::serialize_union_crate_model_event_reference(
&mut object_147,
item_146,
)?;
object_147.finish();
}
}
array_145.finish();
}
if let Some(var_148) = &input.event_time {
object
.key("eventTime")
.date_time(var_148, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_149) = &input.event_type {
object.key("eventType").string(var_149.as_str());
}
if let Some(var_150) = &input.incident_record_arn {
object.key("incidentRecordArn").string(var_150.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_region_map_input_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RegionMapInputValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_151) = &input.sse_kms_key_id {
object.key("sseKmsKeyId").string(var_151.as_str());
}
Ok(())
}
pub fn serialize_union_crate_model_action(
object_14: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Action,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::Action::SsmAutomation(inner) => {
#[allow(unused_mut)]
let mut object_152 = object_14.key("ssmAutomation").start_object();
crate::json_ser::serialize_structure_crate_model_ssm_automation(
&mut object_152,
inner,
)?;
object_152.finish();
}
crate::model::Action::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant("Action"),
)
}
}
Ok(())
}
pub fn serialize_union_crate_model_chat_channel(
object_16: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ChatChannel,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::ChatChannel::Empty(inner) => {
#[allow(unused_mut)]
let mut object_153 = object_16.key("empty").start_object();
crate::json_ser::serialize_structure_crate_model_empty_chat_channel(
&mut object_153,
inner,
)?;
object_153.finish();
}
crate::model::ChatChannel::ChatbotSns(inner) => {
let mut array_154 = object_16.key("chatbotSns").start_array();
for item_155 in inner {
{
array_154.value().string(item_155.as_str());
}
}
array_154.finish();
}
crate::model::ChatChannel::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"ChatChannel",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_incident_template(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IncidentTemplate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_156) = &input.title {
object.key("title").string(var_156.as_str());
}
if let Some(var_157) = &input.impact {
object.key("impact").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_157).into()),
);
}
if let Some(var_158) = &input.summary {
object.key("summary").string(var_158.as_str());
}
if let Some(var_159) = &input.dedupe_string {
object.key("dedupeString").string(var_159.as_str());
}
if let Some(var_160) = &input.notification_targets {
let mut array_161 = object.key("notificationTargets").start_array();
for item_162 in var_160 {
{
#[allow(unused_mut)]
let mut object_163 = array_161.value().start_object();
crate::json_ser::serialize_union_crate_model_notification_target_item(
&mut object_163,
item_162,
)?;
object_163.finish();
}
}
array_161.finish();
}
if let Some(var_164) = &input.incident_tags {
#[allow(unused_mut)]
let mut object_165 = object.key("incidentTags").start_object();
for (key_166, value_167) in var_164 {
{
object_165.key(key_166.as_str()).string(value_167.as_str());
}
}
object_165.finish();
}
Ok(())
}
pub fn serialize_union_crate_model_integration(
object_27: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Integration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::Integration::PagerDutyConfiguration(inner) => {
#[allow(unused_mut)]
let mut object_168 = object_27.key("pagerDutyConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_pager_duty_configuration(
&mut object_168,
inner,
)?;
object_168.finish();
}
crate::model::Integration::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"Integration",
),
)
}
}
Ok(())
}
pub fn serialize_union_crate_model_event_reference(
object_38: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EventReference,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::EventReference::Resource(inner) => {
object_38.key("resource").string(inner.as_str());
}
crate::model::EventReference::RelatedItemId(inner) => {
object_38.key("relatedItemId").string(inner.as_str());
}
crate::model::EventReference::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"EventReference",
),
)
}
}
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_169) = &input.key {
object.key("key").string(var_169.as_str());
}
if let Some(var_170) = &input.condition {
#[allow(unused_mut)]
let mut object_171 = object.key("condition").start_object();
crate::json_ser::serialize_union_crate_model_condition(&mut object_171, var_170)?;
object_171.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_related_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RelatedItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_172) = &input.identifier {
#[allow(unused_mut)]
let mut object_173 = object.key("identifier").start_object();
crate::json_ser::serialize_structure_crate_model_item_identifier(&mut object_173, var_172)?;
object_173.finish();
}
if let Some(var_174) = &input.title {
object.key("title").string(var_174.as_str());
}
if let Some(var_175) = &input.generated_id {
object.key("generatedId").string(var_175.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_trigger_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TriggerDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_176) = &input.source {
object.key("source").string(var_176.as_str());
}
if let Some(var_177) = &input.trigger_arn {
object.key("triggerArn").string(var_177.as_str());
}
if let Some(var_178) = &input.timestamp {
object
.key("timestamp")
.date_time(var_178, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_179) = &input.raw_data {
object.key("rawData").string(var_179.as_str());
}
Ok(())
}
pub fn serialize_union_crate_model_notification_target_item(
object_99: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NotificationTargetItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::NotificationTargetItem::SnsTopicArn(inner) => {
object_99.key("snsTopicArn").string(inner.as_str());
}
crate::model::NotificationTargetItem::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"NotificationTargetItem",
),
)
}
}
Ok(())
}
pub fn serialize_union_crate_model_related_items_update(
object_106: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RelatedItemsUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::RelatedItemsUpdate::ItemToAdd(inner) => {
#[allow(unused_mut)]
let mut object_180 = object_106.key("itemToAdd").start_object();
crate::json_ser::serialize_structure_crate_model_related_item(&mut object_180, inner)?;
object_180.finish();
}
crate::model::RelatedItemsUpdate::ItemToRemove(inner) => {
#[allow(unused_mut)]
let mut object_181 = object_106.key("itemToRemove").start_object();
crate::json_ser::serialize_structure_crate_model_item_identifier(
&mut object_181,
inner,
)?;
object_181.finish();
}
crate::model::RelatedItemsUpdate::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"RelatedItemsUpdate",
),
)
}
}
Ok(())
}
pub fn serialize_union_crate_model_update_replication_set_action(
object_110: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateReplicationSetAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::UpdateReplicationSetAction::AddRegionAction(inner) => {
#[allow(unused_mut)]
let mut object_182 = object_110.key("addRegionAction").start_object();
crate::json_ser::serialize_structure_crate_model_add_region_action(
&mut object_182,
inner,
)?;
object_182.finish();
}
crate::model::UpdateReplicationSetAction::DeleteRegionAction(inner) => {
#[allow(unused_mut)]
let mut object_183 = object_110.key("deleteRegionAction").start_object();
crate::json_ser::serialize_structure_crate_model_delete_region_action(
&mut object_183,
inner,
)?;
object_183.finish();
}
crate::model::UpdateReplicationSetAction::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"UpdateReplicationSetAction",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_ssm_automation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SsmAutomation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_184) = &input.role_arn {
object.key("roleArn").string(var_184.as_str());
}
if let Some(var_185) = &input.document_name {
object.key("documentName").string(var_185.as_str());
}
if let Some(var_186) = &input.document_version {
object.key("documentVersion").string(var_186.as_str());
}
if let Some(var_187) = &input.target_account {
object.key("targetAccount").string(var_187.as_str());
}
if let Some(var_188) = &input.parameters {
#[allow(unused_mut)]
let mut object_189 = object.key("parameters").start_object();
for (key_190, value_191) in var_188 {
{
let mut array_192 = object_189.key(key_190.as_str()).start_array();
for item_193 in value_191 {
{
array_192.value().string(item_193.as_str());
}
}
array_192.finish();
}
}
object_189.finish();
}
if let Some(var_194) = &input.dynamic_parameters {
#[allow(unused_mut)]
let mut object_195 = object.key("dynamicParameters").start_object();
for (key_196, value_197) in var_194 {
{
#[allow(unused_mut)]
let mut object_198 = object_195.key(key_196.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_dynamic_ssm_parameter_value(
&mut object_198,
value_197,
)?;
object_198.finish();
}
}
object_195.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_empty_chat_channel(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EmptyChatChannel,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
Ok(())
}
pub fn serialize_structure_crate_model_pager_duty_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PagerDutyConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_199) = &input.name {
object.key("name").string(var_199.as_str());
}
if let Some(var_200) = &input.secret_id {
object.key("secretId").string(var_200.as_str());
}
if let Some(var_201) = &input.pager_duty_incident_configuration {
#[allow(unused_mut)]
let mut object_202 = object.key("pagerDutyIncidentConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_pager_duty_incident_configuration(
&mut object_202,
var_201,
)?;
object_202.finish();
}
Ok(())
}
pub fn serialize_union_crate_model_condition(
object_171: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Condition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::Condition::Before(inner) => {
object_171
.key("before")
.date_time(inner, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
crate::model::Condition::After(inner) => {
object_171
.key("after")
.date_time(inner, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
crate::model::Condition::Equals(inner) => {
#[allow(unused_mut)]
let mut object_203 = object_171.key("equals").start_object();
crate::json_ser::serialize_union_crate_model_attribute_value_list(
&mut object_203,
inner,
)?;
object_203.finish();
}
crate::model::Condition::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant("Condition"),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_item_identifier(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ItemIdentifier,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_204) = &input.value {
#[allow(unused_mut)]
let mut object_205 = object.key("value").start_object();
crate::json_ser::serialize_union_crate_model_item_value(&mut object_205, var_204)?;
object_205.finish();
}
if let Some(var_206) = &input.r#type {
object.key("type").string(var_206.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_add_region_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AddRegionAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_207) = &input.region_name {
object.key("regionName").string(var_207.as_str());
}
if let Some(var_208) = &input.sse_kms_key_id {
object.key("sseKmsKeyId").string(var_208.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_delete_region_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeleteRegionAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_209) = &input.region_name {
object.key("regionName").string(var_209.as_str());
}
Ok(())
}
pub fn serialize_union_crate_model_dynamic_ssm_parameter_value(
object_198: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DynamicSsmParameterValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::DynamicSsmParameterValue::Variable(inner) => {
object_198.key("variable").string(inner.as_str());
}
crate::model::DynamicSsmParameterValue::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"DynamicSsmParameterValue",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_pager_duty_incident_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PagerDutyIncidentConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_210) = &input.service_id {
object.key("serviceId").string(var_210.as_str());
}
Ok(())
}
pub fn serialize_union_crate_model_attribute_value_list(
object_203: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AttributeValueList,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::AttributeValueList::StringValues(inner) => {
let mut array_211 = object_203.key("stringValues").start_array();
for item_212 in inner {
{
array_211.value().string(item_212.as_str());
}
}
array_211.finish();
}
crate::model::AttributeValueList::IntegerValues(inner) => {
let mut array_213 = object_203.key("integerValues").start_array();
for item_214 in inner {
{
array_213.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*item_214).into()),
);
}
}
array_213.finish();
}
crate::model::AttributeValueList::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"AttributeValueList",
),
)
}
}
Ok(())
}
pub fn serialize_union_crate_model_item_value(
object_205: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ItemValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::ItemValue::Arn(inner) => {
object_205.key("arn").string(inner.as_str());
}
crate::model::ItemValue::Url(inner) => {
object_205.key("url").string(inner.as_str());
}
crate::model::ItemValue::MetricDefinition(inner) => {
object_205.key("metricDefinition").string(inner.as_str());
}
crate::model::ItemValue::PagerDutyIncidentDetail(inner) => {
#[allow(unused_mut)]
let mut object_215 = object_205.key("pagerDutyIncidentDetail").start_object();
crate::json_ser::serialize_structure_crate_model_pager_duty_incident_detail(
&mut object_215,
inner,
)?;
object_215.finish();
}
crate::model::ItemValue::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant("ItemValue"),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_pager_duty_incident_detail(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PagerDutyIncidentDetail,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_216) = &input.id {
object.key("id").string(var_216.as_str());
}
if let Some(var_217) = &input.auto_resolve {
object.key("autoResolve").boolean(*var_217);
}
if let Some(var_218) = &input.secret_id {
object.key("secretId").string(var_218.as_str());
}
Ok(())
}