pub fn serialize_structure_crate_input_add_notification_channel_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddNotificationChannelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.config {
#[allow(unused_mut)]
let mut object_2 = object.key("Config").start_object();
crate::json_ser::serialize_structure_crate_model_notification_channel_config(
&mut object_2,
var_1,
)?;
object_2.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_account_overview_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAccountOverviewInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3) = &input.from_time {
object
.key("FromTime")
.date_time(var_3, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_4) = &input.to_time {
object
.key("ToTime")
.date_time(var_4, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_feedback_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFeedbackInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_5) = &input.insight_id {
object.key("InsightId").string(var_5.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_organization_health_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeOrganizationHealthInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_6) = &input.account_ids {
let mut array_7 = object.key("AccountIds").start_array();
for item_8 in var_6 {
{
array_7.value().string(item_8.as_str());
}
}
array_7.finish();
}
if let Some(var_9) = &input.organizational_unit_ids {
let mut array_10 = object.key("OrganizationalUnitIds").start_array();
for item_11 in var_9 {
{
array_10.value().string(item_11.as_str());
}
}
array_10.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_organization_overview_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeOrganizationOverviewInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_12) = &input.account_ids {
let mut array_13 = object.key("AccountIds").start_array();
for item_14 in var_12 {
{
array_13.value().string(item_14.as_str());
}
}
array_13.finish();
}
if let Some(var_15) = &input.from_time {
object
.key("FromTime")
.date_time(var_15, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_16) = &input.organizational_unit_ids {
let mut array_17 = object.key("OrganizationalUnitIds").start_array();
for item_18 in var_16 {
{
array_17.value().string(item_18.as_str());
}
}
array_17.finish();
}
if let Some(var_19) = &input.to_time {
object
.key("ToTime")
.date_time(var_19, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_organization_resource_collection_health_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeOrganizationResourceCollectionHealthInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_20) = &input.account_ids {
let mut array_21 = object.key("AccountIds").start_array();
for item_22 in var_20 {
{
array_21.value().string(item_22.as_str());
}
}
array_21.finish();
}
if let Some(var_23) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_23).into()),
);
}
if let Some(var_24) = &input.next_token {
object.key("NextToken").string(var_24.as_str());
}
if let Some(var_25) = &input.organization_resource_collection_type {
object
.key("OrganizationResourceCollectionType")
.string(var_25.as_str());
}
if let Some(var_26) = &input.organizational_unit_ids {
let mut array_27 = object.key("OrganizationalUnitIds").start_array();
for item_28 in var_26 {
{
array_27.value().string(item_28.as_str());
}
}
array_27.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_anomalies_for_insight_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAnomaliesForInsightInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_29) = &input.account_id {
object.key("AccountId").string(var_29.as_str());
}
if let Some(var_30) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_30).into()),
);
}
if let Some(var_31) = &input.next_token {
object.key("NextToken").string(var_31.as_str());
}
if let Some(var_32) = &input.start_time_range {
#[allow(unused_mut)]
let mut object_33 = object.key("StartTimeRange").start_object();
crate::json_ser::serialize_structure_crate_model_start_time_range(&mut object_33, var_32)?;
object_33.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_anomalous_log_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAnomalousLogGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_34) = &input.insight_id {
object.key("InsightId").string(var_34.as_str());
}
if let Some(var_35) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_35).into()),
);
}
if let Some(var_36) = &input.next_token {
object.key("NextToken").string(var_36.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_events_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListEventsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_37) = &input.account_id {
object.key("AccountId").string(var_37.as_str());
}
if let Some(var_38) = &input.filters {
#[allow(unused_mut)]
let mut object_39 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_list_events_filters(
&mut object_39,
var_38,
)?;
object_39.finish();
}
if let Some(var_40) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_40).into()),
);
}
if let Some(var_41) = &input.next_token {
object.key("NextToken").string(var_41.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_insights_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListInsightsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_42) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_42).into()),
);
}
if let Some(var_43) = &input.next_token {
object.key("NextToken").string(var_43.as_str());
}
if let Some(var_44) = &input.status_filter {
#[allow(unused_mut)]
let mut object_45 = object.key("StatusFilter").start_object();
crate::json_ser::serialize_structure_crate_model_list_insights_status_filter(
&mut object_45,
var_44,
)?;
object_45.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_monitored_resources_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListMonitoredResourcesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_46) = &input.filters {
#[allow(unused_mut)]
let mut object_47 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_list_monitored_resources_filters(
&mut object_47,
var_46,
)?;
object_47.finish();
}
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_notification_channels_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListNotificationChannelsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.next_token {
object.key("NextToken").string(var_50.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_organization_insights_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListOrganizationInsightsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_51) = &input.account_ids {
let mut array_52 = object.key("AccountIds").start_array();
for item_53 in var_51 {
{
array_52.value().string(item_53.as_str());
}
}
array_52.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());
}
if let Some(var_56) = &input.organizational_unit_ids {
let mut array_57 = object.key("OrganizationalUnitIds").start_array();
for item_58 in var_56 {
{
array_57.value().string(item_58.as_str());
}
}
array_57.finish();
}
if let Some(var_59) = &input.status_filter {
#[allow(unused_mut)]
let mut object_60 = object.key("StatusFilter").start_object();
crate::json_ser::serialize_structure_crate_model_list_insights_status_filter(
&mut object_60,
var_59,
)?;
object_60.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_recommendations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListRecommendationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_61) = &input.account_id {
object.key("AccountId").string(var_61.as_str());
}
if let Some(var_62) = &input.insight_id {
object.key("InsightId").string(var_62.as_str());
}
if let Some(var_63) = &input.locale {
object.key("Locale").string(var_63.as_str());
}
if let Some(var_64) = &input.next_token {
object.key("NextToken").string(var_64.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_feedback_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutFeedbackInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_65) = &input.insight_feedback {
#[allow(unused_mut)]
let mut object_66 = object.key("InsightFeedback").start_object();
crate::json_ser::serialize_structure_crate_model_insight_feedback(&mut object_66, var_65)?;
object_66.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_search_insights_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchInsightsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_67) = &input.filters {
#[allow(unused_mut)]
let mut object_68 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_search_insights_filters(
&mut object_68,
var_67,
)?;
object_68.finish();
}
if let Some(var_69) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_69).into()),
);
}
if let Some(var_70) = &input.next_token {
object.key("NextToken").string(var_70.as_str());
}
if let Some(var_71) = &input.start_time_range {
#[allow(unused_mut)]
let mut object_72 = object.key("StartTimeRange").start_object();
crate::json_ser::serialize_structure_crate_model_start_time_range(&mut object_72, var_71)?;
object_72.finish();
}
if let Some(var_73) = &input.r#type {
object.key("Type").string(var_73.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_search_organization_insights_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchOrganizationInsightsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_74) = &input.account_ids {
let mut array_75 = object.key("AccountIds").start_array();
for item_76 in var_74 {
{
array_75.value().string(item_76.as_str());
}
}
array_75.finish();
}
if let Some(var_77) = &input.filters {
#[allow(unused_mut)]
let mut object_78 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_search_organization_insights_filters(
&mut object_78,
var_77,
)?;
object_78.finish();
}
if let Some(var_79) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_79).into()),
);
}
if let Some(var_80) = &input.next_token {
object.key("NextToken").string(var_80.as_str());
}
if let Some(var_81) = &input.start_time_range {
#[allow(unused_mut)]
let mut object_82 = object.key("StartTimeRange").start_object();
crate::json_ser::serialize_structure_crate_model_start_time_range(&mut object_82, var_81)?;
object_82.finish();
}
if let Some(var_83) = &input.r#type {
object.key("Type").string(var_83.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_cost_estimation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartCostEstimationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_84) = &input.client_token {
object.key("ClientToken").string(var_84.as_str());
}
if let Some(var_85) = &input.resource_collection {
#[allow(unused_mut)]
let mut object_86 = object.key("ResourceCollection").start_object();
crate::json_ser::serialize_structure_crate_model_cost_estimation_resource_collection_filter(&mut object_86, var_85)?;
object_86.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_event_sources_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateEventSourcesConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_87) = &input.event_sources {
#[allow(unused_mut)]
let mut object_88 = object.key("EventSources").start_object();
crate::json_ser::serialize_structure_crate_model_event_sources_config(
&mut object_88,
var_87,
)?;
object_88.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_resource_collection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateResourceCollectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.action {
object.key("Action").string(var_89.as_str());
}
if let Some(var_90) = &input.resource_collection {
#[allow(unused_mut)]
let mut object_91 = object.key("ResourceCollection").start_object();
crate::json_ser::serialize_structure_crate_model_update_resource_collection_filter(
&mut object_91,
var_90,
)?;
object_91.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_service_integration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateServiceIntegrationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_92) = &input.service_integration {
#[allow(unused_mut)]
let mut object_93 = object.key("ServiceIntegration").start_object();
crate::json_ser::serialize_structure_crate_model_update_service_integration_config(
&mut object_93,
var_92,
)?;
object_93.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_notification_channel_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NotificationChannelConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_94) = &input.sns {
#[allow(unused_mut)]
let mut object_95 = object.key("Sns").start_object();
crate::json_ser::serialize_structure_crate_model_sns_channel_config(
&mut object_95,
var_94,
)?;
object_95.finish();
}
if let Some(var_96) = &input.filters {
#[allow(unused_mut)]
let mut object_97 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_notification_filter_config(
&mut object_97,
var_96,
)?;
object_97.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_start_time_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StartTimeRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_98) = &input.from_time {
object
.key("FromTime")
.date_time(var_98, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_99) = &input.to_time {
object
.key("ToTime")
.date_time(var_99, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_list_events_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListEventsFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_100) = &input.insight_id {
object.key("InsightId").string(var_100.as_str());
}
if let Some(var_101) = &input.event_time_range {
#[allow(unused_mut)]
let mut object_102 = object.key("EventTimeRange").start_object();
crate::json_ser::serialize_structure_crate_model_event_time_range(
&mut object_102,
var_101,
)?;
object_102.finish();
}
if let Some(var_103) = &input.event_class {
object.key("EventClass").string(var_103.as_str());
}
if let Some(var_104) = &input.event_source {
object.key("EventSource").string(var_104.as_str());
}
if let Some(var_105) = &input.data_source {
object.key("DataSource").string(var_105.as_str());
}
if let Some(var_106) = &input.resource_collection {
#[allow(unused_mut)]
let mut object_107 = object.key("ResourceCollection").start_object();
crate::json_ser::serialize_structure_crate_model_resource_collection(
&mut object_107,
var_106,
)?;
object_107.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_list_insights_status_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListInsightsStatusFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_108) = &input.ongoing {
#[allow(unused_mut)]
let mut object_109 = object.key("Ongoing").start_object();
crate::json_ser::serialize_structure_crate_model_list_insights_ongoing_status_filter(
&mut object_109,
var_108,
)?;
object_109.finish();
}
if let Some(var_110) = &input.closed {
#[allow(unused_mut)]
let mut object_111 = object.key("Closed").start_object();
crate::json_ser::serialize_structure_crate_model_list_insights_closed_status_filter(
&mut object_111,
var_110,
)?;
object_111.finish();
}
if let Some(var_112) = &input.any {
#[allow(unused_mut)]
let mut object_113 = object.key("Any").start_object();
crate::json_ser::serialize_structure_crate_model_list_insights_any_status_filter(
&mut object_113,
var_112,
)?;
object_113.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_list_monitored_resources_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListMonitoredResourcesFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_114) = &input.resource_permission {
object.key("ResourcePermission").string(var_114.as_str());
}
if let Some(var_115) = &input.resource_type_filters {
let mut array_116 = object.key("ResourceTypeFilters").start_array();
for item_117 in var_115 {
{
array_116.value().string(item_117.as_str());
}
}
array_116.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_insight_feedback(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InsightFeedback,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_118) = &input.id {
object.key("Id").string(var_118.as_str());
}
if let Some(var_119) = &input.feedback {
object.key("Feedback").string(var_119.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_search_insights_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SearchInsightsFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_120) = &input.severities {
let mut array_121 = object.key("Severities").start_array();
for item_122 in var_120 {
{
array_121.value().string(item_122.as_str());
}
}
array_121.finish();
}
if let Some(var_123) = &input.statuses {
let mut array_124 = object.key("Statuses").start_array();
for item_125 in var_123 {
{
array_124.value().string(item_125.as_str());
}
}
array_124.finish();
}
if let Some(var_126) = &input.resource_collection {
#[allow(unused_mut)]
let mut object_127 = object.key("ResourceCollection").start_object();
crate::json_ser::serialize_structure_crate_model_resource_collection(
&mut object_127,
var_126,
)?;
object_127.finish();
}
if let Some(var_128) = &input.service_collection {
#[allow(unused_mut)]
let mut object_129 = object.key("ServiceCollection").start_object();
crate::json_ser::serialize_structure_crate_model_service_collection(
&mut object_129,
var_128,
)?;
object_129.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_search_organization_insights_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SearchOrganizationInsightsFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_130) = &input.severities {
let mut array_131 = object.key("Severities").start_array();
for item_132 in var_130 {
{
array_131.value().string(item_132.as_str());
}
}
array_131.finish();
}
if let Some(var_133) = &input.statuses {
let mut array_134 = object.key("Statuses").start_array();
for item_135 in var_133 {
{
array_134.value().string(item_135.as_str());
}
}
array_134.finish();
}
if let Some(var_136) = &input.resource_collection {
#[allow(unused_mut)]
let mut object_137 = object.key("ResourceCollection").start_object();
crate::json_ser::serialize_structure_crate_model_resource_collection(
&mut object_137,
var_136,
)?;
object_137.finish();
}
if let Some(var_138) = &input.service_collection {
#[allow(unused_mut)]
let mut object_139 = object.key("ServiceCollection").start_object();
crate::json_ser::serialize_structure_crate_model_service_collection(
&mut object_139,
var_138,
)?;
object_139.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_cost_estimation_resource_collection_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CostEstimationResourceCollectionFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_140) = &input.cloud_formation {
#[allow(unused_mut)]
let mut object_141 = object.key("CloudFormation").start_object();
crate::json_ser::serialize_structure_crate_model_cloud_formation_cost_estimation_resource_collection_filter(&mut object_141, var_140)?;
object_141.finish();
}
if let Some(var_142) = &input.tags {
let mut array_143 = object.key("Tags").start_array();
for item_144 in var_142 {
{
#[allow(unused_mut)]
let mut object_145 = array_143.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_cost_estimation_resource_collection_filter(&mut object_145, item_144)?;
object_145.finish();
}
}
array_143.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_event_sources_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EventSourcesConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.amazon_code_guru_profiler {
#[allow(unused_mut)]
let mut object_147 = object.key("AmazonCodeGuruProfiler").start_object();
crate::json_ser::serialize_structure_crate_model_amazon_code_guru_profiler_integration(
&mut object_147,
var_146,
)?;
object_147.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_resource_collection_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateResourceCollectionFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_148) = &input.cloud_formation {
#[allow(unused_mut)]
let mut object_149 = object.key("CloudFormation").start_object();
crate::json_ser::serialize_structure_crate_model_update_cloud_formation_collection_filter(
&mut object_149,
var_148,
)?;
object_149.finish();
}
if let Some(var_150) = &input.tags {
let mut array_151 = object.key("Tags").start_array();
for item_152 in var_150 {
{
#[allow(unused_mut)]
let mut object_153 = array_151.value().start_object();
crate::json_ser::serialize_structure_crate_model_update_tag_collection_filter(
&mut object_153,
item_152,
)?;
object_153.finish();
}
}
array_151.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_service_integration_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateServiceIntegrationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_154) = &input.ops_center {
#[allow(unused_mut)]
let mut object_155 = object.key("OpsCenter").start_object();
crate::json_ser::serialize_structure_crate_model_ops_center_integration_config(
&mut object_155,
var_154,
)?;
object_155.finish();
}
if let Some(var_156) = &input.logs_anomaly_detection {
#[allow(unused_mut)]
let mut object_157 = object.key("LogsAnomalyDetection").start_object();
crate::json_ser::serialize_structure_crate_model_logs_anomaly_detection_integration_config(
&mut object_157,
var_156,
)?;
object_157.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sns_channel_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SnsChannelConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_158) = &input.topic_arn {
object.key("TopicArn").string(var_158.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_notification_filter_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NotificationFilterConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_159) = &input.severities {
let mut array_160 = object.key("Severities").start_array();
for item_161 in var_159 {
{
array_160.value().string(item_161.as_str());
}
}
array_160.finish();
}
if let Some(var_162) = &input.message_types {
let mut array_163 = object.key("MessageTypes").start_array();
for item_164 in var_162 {
{
array_163.value().string(item_164.as_str());
}
}
array_163.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_event_time_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EventTimeRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_165) = &input.from_time {
object
.key("FromTime")
.date_time(var_165, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_166) = &input.to_time {
object
.key("ToTime")
.date_time(var_166, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_collection(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceCollection,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_167) = &input.cloud_formation {
#[allow(unused_mut)]
let mut object_168 = object.key("CloudFormation").start_object();
crate::json_ser::serialize_structure_crate_model_cloud_formation_collection(
&mut object_168,
var_167,
)?;
object_168.finish();
}
if let Some(var_169) = &input.tags {
let mut array_170 = object.key("Tags").start_array();
for item_171 in var_169 {
{
#[allow(unused_mut)]
let mut object_172 = array_170.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_collection(
&mut object_172,
item_171,
)?;
object_172.finish();
}
}
array_170.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_list_insights_ongoing_status_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListInsightsOngoingStatusFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_173) = &input.r#type {
object.key("Type").string(var_173.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_list_insights_closed_status_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListInsightsClosedStatusFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_174) = &input.r#type {
object.key("Type").string(var_174.as_str());
}
if let Some(var_175) = &input.end_time_range {
#[allow(unused_mut)]
let mut object_176 = object.key("EndTimeRange").start_object();
crate::json_ser::serialize_structure_crate_model_end_time_range(&mut object_176, var_175)?;
object_176.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_list_insights_any_status_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListInsightsAnyStatusFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_177) = &input.r#type {
object.key("Type").string(var_177.as_str());
}
if let Some(var_178) = &input.start_time_range {
#[allow(unused_mut)]
let mut object_179 = object.key("StartTimeRange").start_object();
crate::json_ser::serialize_structure_crate_model_start_time_range(
&mut object_179,
var_178,
)?;
object_179.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_service_collection(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServiceCollection,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_180) = &input.service_names {
let mut array_181 = object.key("ServiceNames").start_array();
for item_182 in var_180 {
{
array_181.value().string(item_182.as_str());
}
}
array_181.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_cloud_formation_cost_estimation_resource_collection_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CloudFormationCostEstimationResourceCollectionFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_183) = &input.stack_names {
let mut array_184 = object.key("StackNames").start_array();
for item_185 in var_183 {
{
array_184.value().string(item_185.as_str());
}
}
array_184.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tag_cost_estimation_resource_collection_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TagCostEstimationResourceCollectionFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_186) = &input.app_boundary_key {
object.key("AppBoundaryKey").string(var_186.as_str());
}
if let Some(var_187) = &input.tag_values {
let mut array_188 = object.key("TagValues").start_array();
for item_189 in var_187 {
{
array_188.value().string(item_189.as_str());
}
}
array_188.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_amazon_code_guru_profiler_integration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AmazonCodeGuruProfilerIntegration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_190) = &input.status {
object.key("Status").string(var_190.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update_cloud_formation_collection_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateCloudFormationCollectionFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_191) = &input.stack_names {
let mut array_192 = object.key("StackNames").start_array();
for item_193 in var_191 {
{
array_192.value().string(item_193.as_str());
}
}
array_192.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_tag_collection_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateTagCollectionFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_194) = &input.app_boundary_key {
object.key("AppBoundaryKey").string(var_194.as_str());
}
if let Some(var_195) = &input.tag_values {
let mut array_196 = object.key("TagValues").start_array();
for item_197 in var_195 {
{
array_196.value().string(item_197.as_str());
}
}
array_196.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_ops_center_integration_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OpsCenterIntegrationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_198) = &input.opt_in_status {
object.key("OptInStatus").string(var_198.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_logs_anomaly_detection_integration_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LogsAnomalyDetectionIntegrationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_199) = &input.opt_in_status {
object.key("OptInStatus").string(var_199.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_cloud_formation_collection(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CloudFormationCollection,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_200) = &input.stack_names {
let mut array_201 = object.key("StackNames").start_array();
for item_202 in var_200 {
{
array_201.value().string(item_202.as_str());
}
}
array_201.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tag_collection(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TagCollection,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_203) = &input.app_boundary_key {
object.key("AppBoundaryKey").string(var_203.as_str());
}
if let Some(var_204) = &input.tag_values {
let mut array_205 = object.key("TagValues").start_array();
for item_206 in var_204 {
{
array_205.value().string(item_206.as_str());
}
}
array_205.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_end_time_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EndTimeRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_207) = &input.from_time {
object
.key("FromTime")
.date_time(var_207, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_208) = &input.to_time {
object
.key("ToTime")
.date_time(var_208, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}