pub fn serialize_structure_crate_input_describe_affected_accounts_for_organization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAffectedAccountsForOrganizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.event_arn {
object.key("eventArn").string(var_1.as_str());
}
if let Some(var_2) = &input.next_token {
object.key("nextToken").string(var_2.as_str());
}
if let Some(var_3) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_3).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_affected_entities_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAffectedEntitiesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_4) = &input.filter {
#[allow(unused_mut)]
let mut object_5 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_entity_filter(&mut object_5, var_4)?;
object_5.finish();
}
if let Some(var_6) = &input.locale {
object.key("locale").string(var_6.as_str());
}
if let Some(var_7) = &input.next_token {
object.key("nextToken").string(var_7.as_str());
}
if let Some(var_8) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_8).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_affected_entities_for_organization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAffectedEntitiesForOrganizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_9) = &input.organization_entity_filters {
let mut array_10 = object.key("organizationEntityFilters").start_array();
for item_11 in var_9 {
{
#[allow(unused_mut)]
let mut object_12 = array_10.value().start_object();
crate::json_ser::serialize_structure_crate_model_event_account_filter(
&mut object_12,
item_11,
)?;
object_12.finish();
}
}
array_10.finish();
}
if let Some(var_13) = &input.locale {
object.key("locale").string(var_13.as_str());
}
if let Some(var_14) = &input.next_token {
object.key("nextToken").string(var_14.as_str());
}
if let Some(var_15) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_15).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_entity_aggregates_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEntityAggregatesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_16) = &input.event_arns {
let mut array_17 = object.key("eventArns").start_array();
for item_18 in var_16 {
{
array_17.value().string(item_18.as_str());
}
}
array_17.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_event_aggregates_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEventAggregatesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_19) = &input.filter {
#[allow(unused_mut)]
let mut object_20 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_event_filter(&mut object_20, var_19)?;
object_20.finish();
}
if let Some(var_21) = &input.aggregate_field {
object.key("aggregateField").string(var_21.as_str());
}
if let Some(var_22) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_22).into()),
);
}
if let Some(var_23) = &input.next_token {
object.key("nextToken").string(var_23.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_event_details_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEventDetailsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_24) = &input.event_arns {
let mut array_25 = object.key("eventArns").start_array();
for item_26 in var_24 {
{
array_25.value().string(item_26.as_str());
}
}
array_25.finish();
}
if let Some(var_27) = &input.locale {
object.key("locale").string(var_27.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_event_details_for_organization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEventDetailsForOrganizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_28) = &input.organization_event_detail_filters {
let mut array_29 = object.key("organizationEventDetailFilters").start_array();
for item_30 in var_28 {
{
#[allow(unused_mut)]
let mut object_31 = array_29.value().start_object();
crate::json_ser::serialize_structure_crate_model_event_account_filter(
&mut object_31,
item_30,
)?;
object_31.finish();
}
}
array_29.finish();
}
if let Some(var_32) = &input.locale {
object.key("locale").string(var_32.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_events_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEventsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_33) = &input.filter {
#[allow(unused_mut)]
let mut object_34 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_event_filter(&mut object_34, var_33)?;
object_34.finish();
}
if let Some(var_35) = &input.next_token {
object.key("nextToken").string(var_35.as_str());
}
if let Some(var_36) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_36).into()),
);
}
if let Some(var_37) = &input.locale {
object.key("locale").string(var_37.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_events_for_organization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEventsForOrganizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_38) = &input.filter {
#[allow(unused_mut)]
let mut object_39 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_organization_event_filter(
&mut object_39,
var_38,
)?;
object_39.finish();
}
if let Some(var_40) = &input.next_token {
object.key("nextToken").string(var_40.as_str());
}
if let Some(var_41) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_41).into()),
);
}
if let Some(var_42) = &input.locale {
object.key("locale").string(var_42.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_event_types_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEventTypesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_43) = &input.filter {
#[allow(unused_mut)]
let mut object_44 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_event_type_filter(&mut object_44, var_43)?;
object_44.finish();
}
if let Some(var_45) = &input.locale {
object.key("locale").string(var_45.as_str());
}
if let Some(var_46) = &input.next_token {
object.key("nextToken").string(var_46.as_str());
}
if let Some(var_47) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_47).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_entity_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EntityFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_48) = &input.event_arns {
let mut array_49 = object.key("eventArns").start_array();
for item_50 in var_48 {
{
array_49.value().string(item_50.as_str());
}
}
array_49.finish();
}
if let Some(var_51) = &input.entity_arns {
let mut array_52 = object.key("entityArns").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.entity_values {
let mut array_55 = object.key("entityValues").start_array();
for item_56 in var_54 {
{
array_55.value().string(item_56.as_str());
}
}
array_55.finish();
}
if let Some(var_57) = &input.last_updated_times {
let mut array_58 = object.key("lastUpdatedTimes").start_array();
for item_59 in var_57 {
{
#[allow(unused_mut)]
let mut object_60 = array_58.value().start_object();
crate::json_ser::serialize_structure_crate_model_date_time_range(
&mut object_60,
item_59,
)?;
object_60.finish();
}
}
array_58.finish();
}
if let Some(var_61) = &input.tags {
let mut array_62 = object.key("tags").start_array();
for item_63 in var_61 {
{
#[allow(unused_mut)]
let mut object_64 = array_62.value().start_object();
for (key_65, value_66) in item_63 {
{
object_64.key(key_65.as_str()).string(value_66.as_str());
}
}
object_64.finish();
}
}
array_62.finish();
}
if let Some(var_67) = &input.status_codes {
let mut array_68 = object.key("statusCodes").start_array();
for item_69 in var_67 {
{
array_68.value().string(item_69.as_str());
}
}
array_68.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_event_account_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EventAccountFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.event_arn {
object.key("eventArn").string(var_70.as_str());
}
if let Some(var_71) = &input.aws_account_id {
object.key("awsAccountId").string(var_71.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_event_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EventFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_72) = &input.event_arns {
let mut array_73 = object.key("eventArns").start_array();
for item_74 in var_72 {
{
array_73.value().string(item_74.as_str());
}
}
array_73.finish();
}
if let Some(var_75) = &input.event_type_codes {
let mut array_76 = object.key("eventTypeCodes").start_array();
for item_77 in var_75 {
{
array_76.value().string(item_77.as_str());
}
}
array_76.finish();
}
if let Some(var_78) = &input.services {
let mut array_79 = object.key("services").start_array();
for item_80 in var_78 {
{
array_79.value().string(item_80.as_str());
}
}
array_79.finish();
}
if let Some(var_81) = &input.regions {
let mut array_82 = object.key("regions").start_array();
for item_83 in var_81 {
{
array_82.value().string(item_83.as_str());
}
}
array_82.finish();
}
if let Some(var_84) = &input.availability_zones {
let mut array_85 = object.key("availabilityZones").start_array();
for item_86 in var_84 {
{
array_85.value().string(item_86.as_str());
}
}
array_85.finish();
}
if let Some(var_87) = &input.start_times {
let mut array_88 = object.key("startTimes").start_array();
for item_89 in var_87 {
{
#[allow(unused_mut)]
let mut object_90 = array_88.value().start_object();
crate::json_ser::serialize_structure_crate_model_date_time_range(
&mut object_90,
item_89,
)?;
object_90.finish();
}
}
array_88.finish();
}
if let Some(var_91) = &input.end_times {
let mut array_92 = object.key("endTimes").start_array();
for item_93 in var_91 {
{
#[allow(unused_mut)]
let mut object_94 = array_92.value().start_object();
crate::json_ser::serialize_structure_crate_model_date_time_range(
&mut object_94,
item_93,
)?;
object_94.finish();
}
}
array_92.finish();
}
if let Some(var_95) = &input.last_updated_times {
let mut array_96 = object.key("lastUpdatedTimes").start_array();
for item_97 in var_95 {
{
#[allow(unused_mut)]
let mut object_98 = array_96.value().start_object();
crate::json_ser::serialize_structure_crate_model_date_time_range(
&mut object_98,
item_97,
)?;
object_98.finish();
}
}
array_96.finish();
}
if let Some(var_99) = &input.entity_arns {
let mut array_100 = object.key("entityArns").start_array();
for item_101 in var_99 {
{
array_100.value().string(item_101.as_str());
}
}
array_100.finish();
}
if let Some(var_102) = &input.entity_values {
let mut array_103 = object.key("entityValues").start_array();
for item_104 in var_102 {
{
array_103.value().string(item_104.as_str());
}
}
array_103.finish();
}
if let Some(var_105) = &input.event_type_categories {
let mut array_106 = object.key("eventTypeCategories").start_array();
for item_107 in var_105 {
{
array_106.value().string(item_107.as_str());
}
}
array_106.finish();
}
if let Some(var_108) = &input.tags {
let mut array_109 = object.key("tags").start_array();
for item_110 in var_108 {
{
#[allow(unused_mut)]
let mut object_111 = array_109.value().start_object();
for (key_112, value_113) in item_110 {
{
object_111.key(key_112.as_str()).string(value_113.as_str());
}
}
object_111.finish();
}
}
array_109.finish();
}
if let Some(var_114) = &input.event_status_codes {
let mut array_115 = object.key("eventStatusCodes").start_array();
for item_116 in var_114 {
{
array_115.value().string(item_116.as_str());
}
}
array_115.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_organization_event_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OrganizationEventFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_117) = &input.event_type_codes {
let mut array_118 = object.key("eventTypeCodes").start_array();
for item_119 in var_117 {
{
array_118.value().string(item_119.as_str());
}
}
array_118.finish();
}
if let Some(var_120) = &input.aws_account_ids {
let mut array_121 = object.key("awsAccountIds").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.services {
let mut array_124 = object.key("services").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.regions {
let mut array_127 = object.key("regions").start_array();
for item_128 in var_126 {
{
array_127.value().string(item_128.as_str());
}
}
array_127.finish();
}
if let Some(var_129) = &input.start_time {
#[allow(unused_mut)]
let mut object_130 = object.key("startTime").start_object();
crate::json_ser::serialize_structure_crate_model_date_time_range(&mut object_130, var_129)?;
object_130.finish();
}
if let Some(var_131) = &input.end_time {
#[allow(unused_mut)]
let mut object_132 = object.key("endTime").start_object();
crate::json_ser::serialize_structure_crate_model_date_time_range(&mut object_132, var_131)?;
object_132.finish();
}
if let Some(var_133) = &input.last_updated_time {
#[allow(unused_mut)]
let mut object_134 = object.key("lastUpdatedTime").start_object();
crate::json_ser::serialize_structure_crate_model_date_time_range(&mut object_134, var_133)?;
object_134.finish();
}
if let Some(var_135) = &input.entity_arns {
let mut array_136 = object.key("entityArns").start_array();
for item_137 in var_135 {
{
array_136.value().string(item_137.as_str());
}
}
array_136.finish();
}
if let Some(var_138) = &input.entity_values {
let mut array_139 = object.key("entityValues").start_array();
for item_140 in var_138 {
{
array_139.value().string(item_140.as_str());
}
}
array_139.finish();
}
if let Some(var_141) = &input.event_type_categories {
let mut array_142 = object.key("eventTypeCategories").start_array();
for item_143 in var_141 {
{
array_142.value().string(item_143.as_str());
}
}
array_142.finish();
}
if let Some(var_144) = &input.event_status_codes {
let mut array_145 = object.key("eventStatusCodes").start_array();
for item_146 in var_144 {
{
array_145.value().string(item_146.as_str());
}
}
array_145.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_event_type_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EventTypeFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_147) = &input.event_type_codes {
let mut array_148 = object.key("eventTypeCodes").start_array();
for item_149 in var_147 {
{
array_148.value().string(item_149.as_str());
}
}
array_148.finish();
}
if let Some(var_150) = &input.services {
let mut array_151 = object.key("services").start_array();
for item_152 in var_150 {
{
array_151.value().string(item_152.as_str());
}
}
array_151.finish();
}
if let Some(var_153) = &input.event_type_categories {
let mut array_154 = object.key("eventTypeCategories").start_array();
for item_155 in var_153 {
{
array_154.value().string(item_155.as_str());
}
}
array_154.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_date_time_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DateTimeRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_156) = &input.from {
object
.key("from")
.date_time(var_156, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_157) = &input.to {
object
.key("to")
.date_time(var_157, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}