pub fn serialize_structure_crate_input_batch_get_aggregate_resource_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetAggregateResourceConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.configuration_aggregator_name {
object
.key("ConfigurationAggregatorName")
.string(var_1.as_str());
}
if let Some(var_2) = &input.resource_identifiers {
let mut array_3 = object.key("ResourceIdentifiers").start_array();
for item_4 in var_2 {
{
#[allow(unused_mut)]
let mut object_5 = array_3.value().start_object();
crate::json_ser::serialize_structure_crate_model_aggregate_resource_identifier(
&mut object_5,
item_4,
)?;
object_5.finish();
}
}
array_3.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_get_resource_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetResourceConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_6) = &input.resource_keys {
let mut array_7 = object.key("resourceKeys").start_array();
for item_8 in var_6 {
{
#[allow(unused_mut)]
let mut object_9 = array_7.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_key(
&mut object_9,
item_8,
)?;
object_9.finish();
}
}
array_7.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_aggregation_authorization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAggregationAuthorizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_10) = &input.authorized_account_id {
object.key("AuthorizedAccountId").string(var_10.as_str());
}
if let Some(var_11) = &input.authorized_aws_region {
object.key("AuthorizedAwsRegion").string(var_11.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_config_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteConfigRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_12) = &input.config_rule_name {
object.key("ConfigRuleName").string(var_12.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_configuration_aggregator_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteConfigurationAggregatorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_13) = &input.configuration_aggregator_name {
object
.key("ConfigurationAggregatorName")
.string(var_13.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_configuration_recorder_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteConfigurationRecorderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_14) = &input.configuration_recorder_name {
object
.key("ConfigurationRecorderName")
.string(var_14.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_conformance_pack_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteConformancePackInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_15) = &input.conformance_pack_name {
object.key("ConformancePackName").string(var_15.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_delivery_channel_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteDeliveryChannelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_16) = &input.delivery_channel_name {
object.key("DeliveryChannelName").string(var_16.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_evaluation_results_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteEvaluationResultsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_17) = &input.config_rule_name {
object.key("ConfigRuleName").string(var_17.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_organization_config_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteOrganizationConfigRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_18) = &input.organization_config_rule_name {
object
.key("OrganizationConfigRuleName")
.string(var_18.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_organization_conformance_pack_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteOrganizationConformancePackInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_19) = &input.organization_conformance_pack_name {
object
.key("OrganizationConformancePackName")
.string(var_19.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_pending_aggregation_request_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeletePendingAggregationRequestInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_20) = &input.requester_account_id {
object.key("RequesterAccountId").string(var_20.as_str());
}
if let Some(var_21) = &input.requester_aws_region {
object.key("RequesterAwsRegion").string(var_21.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_remediation_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteRemediationConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_22) = &input.config_rule_name {
object.key("ConfigRuleName").string(var_22.as_str());
}
if let Some(var_23) = &input.resource_type {
object.key("ResourceType").string(var_23.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_remediation_exceptions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteRemediationExceptionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_24) = &input.config_rule_name {
object.key("ConfigRuleName").string(var_24.as_str());
}
if let Some(var_25) = &input.resource_keys {
let mut array_26 = object.key("ResourceKeys").start_array();
for item_27 in var_25 {
{
#[allow(unused_mut)]
let mut object_28 = array_26.value().start_object();
crate::json_ser::serialize_structure_crate_model_remediation_exception_resource_key(&mut object_28, item_27)?;
object_28.finish();
}
}
array_26.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_resource_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteResourceConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_29) = &input.resource_type {
object.key("ResourceType").string(var_29.as_str());
}
if let Some(var_30) = &input.resource_id {
object.key("ResourceId").string(var_30.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_retention_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteRetentionConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.retention_configuration_name {
object
.key("RetentionConfigurationName")
.string(var_31.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_stored_query_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteStoredQueryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_32) = &input.query_name {
object.key("QueryName").string(var_32.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_deliver_config_snapshot_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeliverConfigSnapshotInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_33) = &input.delivery_channel_name {
object.key("deliveryChannelName").string(var_33.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_aggregate_compliance_by_config_rules_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAggregateComplianceByConfigRulesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_34) = &input.configuration_aggregator_name {
object
.key("ConfigurationAggregatorName")
.string(var_34.as_str());
}
if let Some(var_35) = &input.filters {
#[allow(unused_mut)]
let mut object_36 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_config_rule_compliance_filters(
&mut object_36,
var_35,
)?;
object_36.finish();
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_37) = &input.next_token {
object.key("NextToken").string(var_37.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_aggregate_compliance_by_conformance_packs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAggregateComplianceByConformancePacksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_38) = &input.configuration_aggregator_name {
object
.key("ConfigurationAggregatorName")
.string(var_38.as_str());
}
if let Some(var_39) = &input.filters {
#[allow(unused_mut)]
let mut object_40 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_aggregate_conformance_pack_compliance_filters(&mut object_40, var_39)?;
object_40.finish();
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_41) = &input.next_token {
object.key("NextToken").string(var_41.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_aggregation_authorizations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAggregationAuthorizationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_42) = &input.next_token {
object.key("NextToken").string(var_42.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_compliance_by_config_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeComplianceByConfigRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_43) = &input.config_rule_names {
let mut array_44 = object.key("ConfigRuleNames").start_array();
for item_45 in var_43 {
{
array_44.value().string(item_45.as_str());
}
}
array_44.finish();
}
if let Some(var_46) = &input.compliance_types {
let mut array_47 = object.key("ComplianceTypes").start_array();
for item_48 in var_46 {
{
array_47.value().string(item_48.as_str());
}
}
array_47.finish();
}
if let Some(var_49) = &input.next_token {
object.key("NextToken").string(var_49.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_compliance_by_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeComplianceByResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.resource_type {
object.key("ResourceType").string(var_50.as_str());
}
if let Some(var_51) = &input.resource_id {
object.key("ResourceId").string(var_51.as_str());
}
if let Some(var_52) = &input.compliance_types {
let mut array_53 = object.key("ComplianceTypes").start_array();
for item_54 in var_52 {
{
array_53.value().string(item_54.as_str());
}
}
array_53.finish();
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_55) = &input.next_token {
object.key("NextToken").string(var_55.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_config_rule_evaluation_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeConfigRuleEvaluationStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_56) = &input.config_rule_names {
let mut array_57 = object.key("ConfigRuleNames").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.next_token {
object.key("NextToken").string(var_59.as_str());
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_config_rules_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeConfigRulesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_60) = &input.config_rule_names {
let mut array_61 = object.key("ConfigRuleNames").start_array();
for item_62 in var_60 {
{
array_61.value().string(item_62.as_str());
}
}
array_61.finish();
}
if let Some(var_63) = &input.next_token {
object.key("NextToken").string(var_63.as_str());
}
if let Some(var_64) = &input.filters {
#[allow(unused_mut)]
let mut object_65 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_describe_config_rules_filters(
&mut object_65,
var_64,
)?;
object_65.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_configuration_aggregators_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeConfigurationAggregatorsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_66) = &input.configuration_aggregator_names {
let mut array_67 = object.key("ConfigurationAggregatorNames").start_array();
for item_68 in var_66 {
{
array_67.value().string(item_68.as_str());
}
}
array_67.finish();
}
if let Some(var_69) = &input.next_token {
object.key("NextToken").string(var_69.as_str());
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_configuration_aggregator_sources_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeConfigurationAggregatorSourcesStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.configuration_aggregator_name {
object
.key("ConfigurationAggregatorName")
.string(var_70.as_str());
}
if let Some(var_71) = &input.update_status {
let mut array_72 = object.key("UpdateStatus").start_array();
for item_73 in var_71 {
{
array_72.value().string(item_73.as_str());
}
}
array_72.finish();
}
if let Some(var_74) = &input.next_token {
object.key("NextToken").string(var_74.as_str());
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_configuration_recorders_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeConfigurationRecordersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_75) = &input.configuration_recorder_names {
let mut array_76 = object.key("ConfigurationRecorderNames").start_array();
for item_77 in var_75 {
{
array_76.value().string(item_77.as_str());
}
}
array_76.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_configuration_recorder_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeConfigurationRecorderStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_78) = &input.configuration_recorder_names {
let mut array_79 = object.key("ConfigurationRecorderNames").start_array();
for item_80 in var_78 {
{
array_79.value().string(item_80.as_str());
}
}
array_79.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_conformance_pack_compliance_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeConformancePackComplianceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.conformance_pack_name {
object.key("ConformancePackName").string(var_81.as_str());
}
if let Some(var_82) = &input.filters {
#[allow(unused_mut)]
let mut object_83 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_conformance_pack_compliance_filters(
&mut object_83,
var_82,
)?;
object_83.finish();
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_84) = &input.next_token {
object.key("NextToken").string(var_84.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_conformance_packs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeConformancePacksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.conformance_pack_names {
let mut array_86 = object.key("ConformancePackNames").start_array();
for item_87 in var_85 {
{
array_86.value().string(item_87.as_str());
}
}
array_86.finish();
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_88) = &input.next_token {
object.key("NextToken").string(var_88.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_conformance_pack_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeConformancePackStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.conformance_pack_names {
let mut array_90 = object.key("ConformancePackNames").start_array();
for item_91 in var_89 {
{
array_90.value().string(item_91.as_str());
}
}
array_90.finish();
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_92) = &input.next_token {
object.key("NextToken").string(var_92.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_delivery_channels_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDeliveryChannelsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.delivery_channel_names {
let mut array_94 = object.key("DeliveryChannelNames").start_array();
for item_95 in var_93 {
{
array_94.value().string(item_95.as_str());
}
}
array_94.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_delivery_channel_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDeliveryChannelStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_96) = &input.delivery_channel_names {
let mut array_97 = object.key("DeliveryChannelNames").start_array();
for item_98 in var_96 {
{
array_97.value().string(item_98.as_str());
}
}
array_97.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_organization_config_rules_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeOrganizationConfigRulesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_99) = &input.organization_config_rule_names {
let mut array_100 = object.key("OrganizationConfigRuleNames").start_array();
for item_101 in var_99 {
{
array_100.value().string(item_101.as_str());
}
}
array_100.finish();
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_102) = &input.next_token {
object.key("NextToken").string(var_102.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_organization_config_rule_statuses_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeOrganizationConfigRuleStatusesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_103) = &input.organization_config_rule_names {
let mut array_104 = object.key("OrganizationConfigRuleNames").start_array();
for item_105 in var_103 {
{
array_104.value().string(item_105.as_str());
}
}
array_104.finish();
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_106) = &input.next_token {
object.key("NextToken").string(var_106.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_organization_conformance_packs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeOrganizationConformancePacksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_107) = &input.organization_conformance_pack_names {
let mut array_108 = object.key("OrganizationConformancePackNames").start_array();
for item_109 in var_107 {
{
array_108.value().string(item_109.as_str());
}
}
array_108.finish();
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_110) = &input.next_token {
object.key("NextToken").string(var_110.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_organization_conformance_pack_statuses_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeOrganizationConformancePackStatusesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_111) = &input.organization_conformance_pack_names {
let mut array_112 = object.key("OrganizationConformancePackNames").start_array();
for item_113 in var_111 {
{
array_112.value().string(item_113.as_str());
}
}
array_112.finish();
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_114) = &input.next_token {
object.key("NextToken").string(var_114.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_pending_aggregation_requests_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribePendingAggregationRequestsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_115) = &input.next_token {
object.key("NextToken").string(var_115.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_remediation_configurations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeRemediationConfigurationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_116) = &input.config_rule_names {
let mut array_117 = object.key("ConfigRuleNames").start_array();
for item_118 in var_116 {
{
array_117.value().string(item_118.as_str());
}
}
array_117.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_remediation_exceptions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeRemediationExceptionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_119) = &input.config_rule_name {
object.key("ConfigRuleName").string(var_119.as_str());
}
if let Some(var_120) = &input.resource_keys {
let mut array_121 = object.key("ResourceKeys").start_array();
for item_122 in var_120 {
{
#[allow(unused_mut)]
let mut object_123 = array_121.value().start_object();
crate::json_ser::serialize_structure_crate_model_remediation_exception_resource_key(&mut object_123, item_122)?;
object_123.finish();
}
}
array_121.finish();
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_124) = &input.next_token {
object.key("NextToken").string(var_124.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_remediation_execution_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeRemediationExecutionStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_125) = &input.config_rule_name {
object.key("ConfigRuleName").string(var_125.as_str());
}
if let Some(var_126) = &input.resource_keys {
let mut array_127 = object.key("ResourceKeys").start_array();
for item_128 in var_126 {
{
#[allow(unused_mut)]
let mut object_129 = array_127.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_key(
&mut object_129,
item_128,
)?;
object_129.finish();
}
}
array_127.finish();
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_130) = &input.next_token {
object.key("NextToken").string(var_130.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_retention_configurations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeRetentionConfigurationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_131) = &input.retention_configuration_names {
let mut array_132 = object.key("RetentionConfigurationNames").start_array();
for item_133 in var_131 {
{
array_132.value().string(item_133.as_str());
}
}
array_132.finish();
}
if let Some(var_134) = &input.next_token {
object.key("NextToken").string(var_134.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_aggregate_compliance_details_by_config_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetAggregateComplianceDetailsByConfigRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_135) = &input.configuration_aggregator_name {
object
.key("ConfigurationAggregatorName")
.string(var_135.as_str());
}
if let Some(var_136) = &input.config_rule_name {
object.key("ConfigRuleName").string(var_136.as_str());
}
if let Some(var_137) = &input.account_id {
object.key("AccountId").string(var_137.as_str());
}
if let Some(var_138) = &input.aws_region {
object.key("AwsRegion").string(var_138.as_str());
}
if let Some(var_139) = &input.compliance_type {
object.key("ComplianceType").string(var_139.as_str());
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_140) = &input.next_token {
object.key("NextToken").string(var_140.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_aggregate_config_rule_compliance_summary_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetAggregateConfigRuleComplianceSummaryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_141) = &input.configuration_aggregator_name {
object
.key("ConfigurationAggregatorName")
.string(var_141.as_str());
}
if let Some(var_142) = &input.filters {
#[allow(unused_mut)]
let mut object_143 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_config_rule_compliance_summary_filters(
&mut object_143,
var_142,
)?;
object_143.finish();
}
if let Some(var_144) = &input.group_by_key {
object.key("GroupByKey").string(var_144.as_str());
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_145) = &input.next_token {
object.key("NextToken").string(var_145.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_aggregate_conformance_pack_compliance_summary_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetAggregateConformancePackComplianceSummaryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.configuration_aggregator_name {
object
.key("ConfigurationAggregatorName")
.string(var_146.as_str());
}
if let Some(var_147) = &input.filters {
#[allow(unused_mut)]
let mut object_148 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_aggregate_conformance_pack_compliance_summary_filters(&mut object_148, var_147)?;
object_148.finish();
}
if let Some(var_149) = &input.group_by_key {
object.key("GroupByKey").string(var_149.as_str());
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_150) = &input.next_token {
object.key("NextToken").string(var_150.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_aggregate_discovered_resource_counts_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetAggregateDiscoveredResourceCountsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_151) = &input.configuration_aggregator_name {
object
.key("ConfigurationAggregatorName")
.string(var_151.as_str());
}
if let Some(var_152) = &input.filters {
#[allow(unused_mut)]
let mut object_153 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_resource_count_filters(
&mut object_153,
var_152,
)?;
object_153.finish();
}
if let Some(var_154) = &input.group_by_key {
object.key("GroupByKey").string(var_154.as_str());
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_155) = &input.next_token {
object.key("NextToken").string(var_155.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_aggregate_resource_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetAggregateResourceConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_156) = &input.configuration_aggregator_name {
object
.key("ConfigurationAggregatorName")
.string(var_156.as_str());
}
if let Some(var_157) = &input.resource_identifier {
#[allow(unused_mut)]
let mut object_158 = object.key("ResourceIdentifier").start_object();
crate::json_ser::serialize_structure_crate_model_aggregate_resource_identifier(
&mut object_158,
var_157,
)?;
object_158.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_compliance_details_by_config_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetComplianceDetailsByConfigRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_159) = &input.config_rule_name {
object.key("ConfigRuleName").string(var_159.as_str());
}
if let Some(var_160) = &input.compliance_types {
let mut array_161 = object.key("ComplianceTypes").start_array();
for item_162 in var_160 {
{
array_161.value().string(item_162.as_str());
}
}
array_161.finish();
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_163) = &input.next_token {
object.key("NextToken").string(var_163.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_compliance_details_by_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetComplianceDetailsByResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_164) = &input.resource_type {
object.key("ResourceType").string(var_164.as_str());
}
if let Some(var_165) = &input.resource_id {
object.key("ResourceId").string(var_165.as_str());
}
if let Some(var_166) = &input.compliance_types {
let mut array_167 = object.key("ComplianceTypes").start_array();
for item_168 in var_166 {
{
array_167.value().string(item_168.as_str());
}
}
array_167.finish();
}
if let Some(var_169) = &input.next_token {
object.key("NextToken").string(var_169.as_str());
}
if let Some(var_170) = &input.resource_evaluation_id {
object.key("ResourceEvaluationId").string(var_170.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_compliance_summary_by_resource_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetComplianceSummaryByResourceTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_171) = &input.resource_types {
let mut array_172 = object.key("ResourceTypes").start_array();
for item_173 in var_171 {
{
array_172.value().string(item_173.as_str());
}
}
array_172.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_conformance_pack_compliance_details_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetConformancePackComplianceDetailsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_174) = &input.conformance_pack_name {
object.key("ConformancePackName").string(var_174.as_str());
}
if let Some(var_175) = &input.filters {
#[allow(unused_mut)]
let mut object_176 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_conformance_pack_evaluation_filters(
&mut object_176,
var_175,
)?;
object_176.finish();
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_177) = &input.next_token {
object.key("NextToken").string(var_177.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_conformance_pack_compliance_summary_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetConformancePackComplianceSummaryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_178) = &input.conformance_pack_names {
let mut array_179 = object.key("ConformancePackNames").start_array();
for item_180 in var_178 {
{
array_179.value().string(item_180.as_str());
}
}
array_179.finish();
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_181) = &input.next_token {
object.key("NextToken").string(var_181.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_custom_rule_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetCustomRulePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_182) = &input.config_rule_name {
object.key("ConfigRuleName").string(var_182.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_discovered_resource_counts_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetDiscoveredResourceCountsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_183) = &input.resource_types {
let mut array_184 = object.key("resourceTypes").start_array();
for item_185 in var_183 {
{
array_184.value().string(item_185.as_str());
}
}
array_184.finish();
}
if input.limit != 0 {
object.key("limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_186) = &input.next_token {
object.key("nextToken").string(var_186.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_organization_config_rule_detailed_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetOrganizationConfigRuleDetailedStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_187) = &input.organization_config_rule_name {
object
.key("OrganizationConfigRuleName")
.string(var_187.as_str());
}
if let Some(var_188) = &input.filters {
#[allow(unused_mut)]
let mut object_189 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_status_detail_filters(
&mut object_189,
var_188,
)?;
object_189.finish();
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_190) = &input.next_token {
object.key("NextToken").string(var_190.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_organization_conformance_pack_detailed_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetOrganizationConformancePackDetailedStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_191) = &input.organization_conformance_pack_name {
object
.key("OrganizationConformancePackName")
.string(var_191.as_str());
}
if let Some(var_192) = &input.filters {
#[allow(unused_mut)]
let mut object_193 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_organization_resource_detailed_status_filters(&mut object_193, var_192)?;
object_193.finish();
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_194) = &input.next_token {
object.key("NextToken").string(var_194.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_organization_custom_rule_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetOrganizationCustomRulePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_195) = &input.organization_config_rule_name {
object
.key("OrganizationConfigRuleName")
.string(var_195.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_resource_config_history_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetResourceConfigHistoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_196) = &input.resource_type {
object.key("resourceType").string(var_196.as_str());
}
if let Some(var_197) = &input.resource_id {
object.key("resourceId").string(var_197.as_str());
}
if let Some(var_198) = &input.later_time {
object
.key("laterTime")
.date_time(var_198, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_199) = &input.earlier_time {
object
.key("earlierTime")
.date_time(var_199, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_200) = &input.chronological_order {
object.key("chronologicalOrder").string(var_200.as_str());
}
if input.limit != 0 {
object.key("limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_201) = &input.next_token {
object.key("nextToken").string(var_201.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_resource_evaluation_summary_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetResourceEvaluationSummaryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_202) = &input.resource_evaluation_id {
object.key("ResourceEvaluationId").string(var_202.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_stored_query_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetStoredQueryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_203) = &input.query_name {
object.key("QueryName").string(var_203.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_aggregate_discovered_resources_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAggregateDiscoveredResourcesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_204) = &input.configuration_aggregator_name {
object
.key("ConfigurationAggregatorName")
.string(var_204.as_str());
}
if let Some(var_205) = &input.resource_type {
object.key("ResourceType").string(var_205.as_str());
}
if let Some(var_206) = &input.filters {
#[allow(unused_mut)]
let mut object_207 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_resource_filters(
&mut object_207,
var_206,
)?;
object_207.finish();
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_208) = &input.next_token {
object.key("NextToken").string(var_208.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_conformance_pack_compliance_scores_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListConformancePackComplianceScoresInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_209) = &input.filters {
#[allow(unused_mut)]
let mut object_210 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_conformance_pack_compliance_scores_filters(&mut object_210, var_209)?;
object_210.finish();
}
if let Some(var_211) = &input.sort_order {
object.key("SortOrder").string(var_211.as_str());
}
if let Some(var_212) = &input.sort_by {
object.key("SortBy").string(var_212.as_str());
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_213) = &input.next_token {
object.key("NextToken").string(var_213.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_discovered_resources_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDiscoveredResourcesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_214) = &input.resource_type {
object.key("resourceType").string(var_214.as_str());
}
if let Some(var_215) = &input.resource_ids {
let mut array_216 = object.key("resourceIds").start_array();
for item_217 in var_215 {
{
array_216.value().string(item_217.as_str());
}
}
array_216.finish();
}
if let Some(var_218) = &input.resource_name {
object.key("resourceName").string(var_218.as_str());
}
if input.limit != 0 {
object.key("limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if input.include_deleted_resources {
object
.key("includeDeletedResources")
.boolean(input.include_deleted_resources);
}
if let Some(var_219) = &input.next_token {
object.key("nextToken").string(var_219.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_resource_evaluations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListResourceEvaluationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_220) = &input.filters {
#[allow(unused_mut)]
let mut object_221 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_resource_evaluation_filters(
&mut object_221,
var_220,
)?;
object_221.finish();
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_222) = &input.next_token {
object.key("NextToken").string(var_222.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_stored_queries_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListStoredQueriesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_223) = &input.next_token {
object.key("NextToken").string(var_223.as_str());
}
if let Some(var_224) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_224).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_225) = &input.resource_arn {
object.key("ResourceArn").string(var_225.as_str());
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_226) = &input.next_token {
object.key("NextToken").string(var_226.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_aggregation_authorization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutAggregationAuthorizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_227) = &input.authorized_account_id {
object.key("AuthorizedAccountId").string(var_227.as_str());
}
if let Some(var_228) = &input.authorized_aws_region {
object.key("AuthorizedAwsRegion").string(var_228.as_str());
}
if let Some(var_229) = &input.tags {
let mut array_230 = object.key("Tags").start_array();
for item_231 in var_229 {
{
#[allow(unused_mut)]
let mut object_232 = array_230.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_232, item_231)?;
object_232.finish();
}
}
array_230.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_config_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutConfigRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_233) = &input.config_rule {
#[allow(unused_mut)]
let mut object_234 = object.key("ConfigRule").start_object();
crate::json_ser::serialize_structure_crate_model_config_rule(&mut object_234, var_233)?;
object_234.finish();
}
if let Some(var_235) = &input.tags {
let mut array_236 = object.key("Tags").start_array();
for item_237 in var_235 {
{
#[allow(unused_mut)]
let mut object_238 = array_236.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_238, item_237)?;
object_238.finish();
}
}
array_236.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_configuration_aggregator_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutConfigurationAggregatorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_239) = &input.configuration_aggregator_name {
object
.key("ConfigurationAggregatorName")
.string(var_239.as_str());
}
if let Some(var_240) = &input.account_aggregation_sources {
let mut array_241 = object.key("AccountAggregationSources").start_array();
for item_242 in var_240 {
{
#[allow(unused_mut)]
let mut object_243 = array_241.value().start_object();
crate::json_ser::serialize_structure_crate_model_account_aggregation_source(
&mut object_243,
item_242,
)?;
object_243.finish();
}
}
array_241.finish();
}
if let Some(var_244) = &input.organization_aggregation_source {
#[allow(unused_mut)]
let mut object_245 = object.key("OrganizationAggregationSource").start_object();
crate::json_ser::serialize_structure_crate_model_organization_aggregation_source(
&mut object_245,
var_244,
)?;
object_245.finish();
}
if let Some(var_246) = &input.tags {
let mut array_247 = object.key("Tags").start_array();
for item_248 in var_246 {
{
#[allow(unused_mut)]
let mut object_249 = array_247.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_249, item_248)?;
object_249.finish();
}
}
array_247.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_configuration_recorder_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutConfigurationRecorderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_250) = &input.configuration_recorder {
#[allow(unused_mut)]
let mut object_251 = object.key("ConfigurationRecorder").start_object();
crate::json_ser::serialize_structure_crate_model_configuration_recorder(
&mut object_251,
var_250,
)?;
object_251.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_conformance_pack_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutConformancePackInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_252) = &input.conformance_pack_name {
object.key("ConformancePackName").string(var_252.as_str());
}
if let Some(var_253) = &input.template_s3_uri {
object.key("TemplateS3Uri").string(var_253.as_str());
}
if let Some(var_254) = &input.template_body {
object.key("TemplateBody").string(var_254.as_str());
}
if let Some(var_255) = &input.delivery_s3_bucket {
object.key("DeliveryS3Bucket").string(var_255.as_str());
}
if let Some(var_256) = &input.delivery_s3_key_prefix {
object.key("DeliveryS3KeyPrefix").string(var_256.as_str());
}
if let Some(var_257) = &input.conformance_pack_input_parameters {
let mut array_258 = object.key("ConformancePackInputParameters").start_array();
for item_259 in var_257 {
{
#[allow(unused_mut)]
let mut object_260 = array_258.value().start_object();
crate::json_ser::serialize_structure_crate_model_conformance_pack_input_parameter(
&mut object_260,
item_259,
)?;
object_260.finish();
}
}
array_258.finish();
}
if let Some(var_261) = &input.template_ssm_document_details {
#[allow(unused_mut)]
let mut object_262 = object.key("TemplateSSMDocumentDetails").start_object();
crate::json_ser::serialize_structure_crate_model_template_ssm_document_details(
&mut object_262,
var_261,
)?;
object_262.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_delivery_channel_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutDeliveryChannelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_263) = &input.delivery_channel {
#[allow(unused_mut)]
let mut object_264 = object.key("DeliveryChannel").start_object();
crate::json_ser::serialize_structure_crate_model_delivery_channel(
&mut object_264,
var_263,
)?;
object_264.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_evaluations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutEvaluationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_265) = &input.evaluations {
let mut array_266 = object.key("Evaluations").start_array();
for item_267 in var_265 {
{
#[allow(unused_mut)]
let mut object_268 = array_266.value().start_object();
crate::json_ser::serialize_structure_crate_model_evaluation(
&mut object_268,
item_267,
)?;
object_268.finish();
}
}
array_266.finish();
}
if let Some(var_269) = &input.result_token {
object.key("ResultToken").string(var_269.as_str());
}
if input.test_mode {
object.key("TestMode").boolean(input.test_mode);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_external_evaluation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutExternalEvaluationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_270) = &input.config_rule_name {
object.key("ConfigRuleName").string(var_270.as_str());
}
if let Some(var_271) = &input.external_evaluation {
#[allow(unused_mut)]
let mut object_272 = object.key("ExternalEvaluation").start_object();
crate::json_ser::serialize_structure_crate_model_external_evaluation(
&mut object_272,
var_271,
)?;
object_272.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_organization_config_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutOrganizationConfigRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_273) = &input.organization_config_rule_name {
object
.key("OrganizationConfigRuleName")
.string(var_273.as_str());
}
if let Some(var_274) = &input.organization_managed_rule_metadata {
#[allow(unused_mut)]
let mut object_275 = object.key("OrganizationManagedRuleMetadata").start_object();
crate::json_ser::serialize_structure_crate_model_organization_managed_rule_metadata(
&mut object_275,
var_274,
)?;
object_275.finish();
}
if let Some(var_276) = &input.organization_custom_rule_metadata {
#[allow(unused_mut)]
let mut object_277 = object.key("OrganizationCustomRuleMetadata").start_object();
crate::json_ser::serialize_structure_crate_model_organization_custom_rule_metadata(
&mut object_277,
var_276,
)?;
object_277.finish();
}
if let Some(var_278) = &input.excluded_accounts {
let mut array_279 = object.key("ExcludedAccounts").start_array();
for item_280 in var_278 {
{
array_279.value().string(item_280.as_str());
}
}
array_279.finish();
}
if let Some(var_281) = &input.organization_custom_policy_rule_metadata {
#[allow(unused_mut)]
let mut object_282 = object
.key("OrganizationCustomPolicyRuleMetadata")
.start_object();
crate::json_ser::serialize_structure_crate_model_organization_custom_policy_rule_metadata(
&mut object_282,
var_281,
)?;
object_282.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_organization_conformance_pack_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutOrganizationConformancePackInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_283) = &input.organization_conformance_pack_name {
object
.key("OrganizationConformancePackName")
.string(var_283.as_str());
}
if let Some(var_284) = &input.template_s3_uri {
object.key("TemplateS3Uri").string(var_284.as_str());
}
if let Some(var_285) = &input.template_body {
object.key("TemplateBody").string(var_285.as_str());
}
if let Some(var_286) = &input.delivery_s3_bucket {
object.key("DeliveryS3Bucket").string(var_286.as_str());
}
if let Some(var_287) = &input.delivery_s3_key_prefix {
object.key("DeliveryS3KeyPrefix").string(var_287.as_str());
}
if let Some(var_288) = &input.conformance_pack_input_parameters {
let mut array_289 = object.key("ConformancePackInputParameters").start_array();
for item_290 in var_288 {
{
#[allow(unused_mut)]
let mut object_291 = array_289.value().start_object();
crate::json_ser::serialize_structure_crate_model_conformance_pack_input_parameter(
&mut object_291,
item_290,
)?;
object_291.finish();
}
}
array_289.finish();
}
if let Some(var_292) = &input.excluded_accounts {
let mut array_293 = object.key("ExcludedAccounts").start_array();
for item_294 in var_292 {
{
array_293.value().string(item_294.as_str());
}
}
array_293.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_remediation_configurations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutRemediationConfigurationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_295) = &input.remediation_configurations {
let mut array_296 = object.key("RemediationConfigurations").start_array();
for item_297 in var_295 {
{
#[allow(unused_mut)]
let mut object_298 = array_296.value().start_object();
crate::json_ser::serialize_structure_crate_model_remediation_configuration(
&mut object_298,
item_297,
)?;
object_298.finish();
}
}
array_296.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_remediation_exceptions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutRemediationExceptionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_299) = &input.config_rule_name {
object.key("ConfigRuleName").string(var_299.as_str());
}
if let Some(var_300) = &input.resource_keys {
let mut array_301 = object.key("ResourceKeys").start_array();
for item_302 in var_300 {
{
#[allow(unused_mut)]
let mut object_303 = array_301.value().start_object();
crate::json_ser::serialize_structure_crate_model_remediation_exception_resource_key(&mut object_303, item_302)?;
object_303.finish();
}
}
array_301.finish();
}
if let Some(var_304) = &input.message {
object.key("Message").string(var_304.as_str());
}
if let Some(var_305) = &input.expiration_time {
object
.key("ExpirationTime")
.date_time(var_305, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_input_put_resource_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutResourceConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_306) = &input.resource_type {
object.key("ResourceType").string(var_306.as_str());
}
if let Some(var_307) = &input.schema_version_id {
object.key("SchemaVersionId").string(var_307.as_str());
}
if let Some(var_308) = &input.resource_id {
object.key("ResourceId").string(var_308.as_str());
}
if let Some(var_309) = &input.resource_name {
object.key("ResourceName").string(var_309.as_str());
}
if let Some(var_310) = &input.configuration {
object.key("Configuration").string(var_310.as_str());
}
if let Some(var_311) = &input.tags {
#[allow(unused_mut)]
let mut object_312 = object.key("Tags").start_object();
for (key_313, value_314) in var_311 {
{
object_312.key(key_313.as_str()).string(value_314.as_str());
}
}
object_312.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_retention_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutRetentionConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("RetentionPeriodInDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.retention_period_in_days).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_stored_query_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutStoredQueryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_315) = &input.stored_query {
#[allow(unused_mut)]
let mut object_316 = object.key("StoredQuery").start_object();
crate::json_ser::serialize_structure_crate_model_stored_query(&mut object_316, var_315)?;
object_316.finish();
}
if let Some(var_317) = &input.tags {
let mut array_318 = object.key("Tags").start_array();
for item_319 in var_317 {
{
#[allow(unused_mut)]
let mut object_320 = array_318.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_320, item_319)?;
object_320.finish();
}
}
array_318.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_select_aggregate_resource_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SelectAggregateResourceConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_321) = &input.expression {
object.key("Expression").string(var_321.as_str());
}
if let Some(var_322) = &input.configuration_aggregator_name {
object
.key("ConfigurationAggregatorName")
.string(var_322.as_str());
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if input.max_results != 0 {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_323) = &input.next_token {
object.key("NextToken").string(var_323.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_select_resource_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SelectResourceConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_324) = &input.expression {
object.key("Expression").string(var_324.as_str());
}
if input.limit != 0 {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.limit).into()),
);
}
if let Some(var_325) = &input.next_token {
object.key("NextToken").string(var_325.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_config_rules_evaluation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartConfigRulesEvaluationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_326) = &input.config_rule_names {
let mut array_327 = object.key("ConfigRuleNames").start_array();
for item_328 in var_326 {
{
array_327.value().string(item_328.as_str());
}
}
array_327.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_configuration_recorder_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartConfigurationRecorderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_329) = &input.configuration_recorder_name {
object
.key("ConfigurationRecorderName")
.string(var_329.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_remediation_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartRemediationExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_330) = &input.config_rule_name {
object.key("ConfigRuleName").string(var_330.as_str());
}
if let Some(var_331) = &input.resource_keys {
let mut array_332 = object.key("ResourceKeys").start_array();
for item_333 in var_331 {
{
#[allow(unused_mut)]
let mut object_334 = array_332.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_key(
&mut object_334,
item_333,
)?;
object_334.finish();
}
}
array_332.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_resource_evaluation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartResourceEvaluationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_335) = &input.resource_details {
#[allow(unused_mut)]
let mut object_336 = object.key("ResourceDetails").start_object();
crate::json_ser::serialize_structure_crate_model_resource_details(
&mut object_336,
var_335,
)?;
object_336.finish();
}
if let Some(var_337) = &input.evaluation_context {
#[allow(unused_mut)]
let mut object_338 = object.key("EvaluationContext").start_object();
crate::json_ser::serialize_structure_crate_model_evaluation_context(
&mut object_338,
var_337,
)?;
object_338.finish();
}
if let Some(var_339) = &input.evaluation_mode {
object.key("EvaluationMode").string(var_339.as_str());
}
if input.evaluation_timeout != 0 {
object.key("EvaluationTimeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.evaluation_timeout).into()),
);
}
if let Some(var_340) = &input.client_token {
object.key("ClientToken").string(var_340.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_configuration_recorder_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopConfigurationRecorderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_341) = &input.configuration_recorder_name {
object
.key("ConfigurationRecorderName")
.string(var_341.as_str());
}
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_342) = &input.resource_arn {
object.key("ResourceArn").string(var_342.as_str());
}
if let Some(var_343) = &input.tags {
let mut array_344 = object.key("Tags").start_array();
for item_345 in var_343 {
{
#[allow(unused_mut)]
let mut object_346 = array_344.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_346, item_345)?;
object_346.finish();
}
}
array_344.finish();
}
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_347) = &input.resource_arn {
object.key("ResourceArn").string(var_347.as_str());
}
if let Some(var_348) = &input.tag_keys {
let mut array_349 = object.key("TagKeys").start_array();
for item_350 in var_348 {
{
array_349.value().string(item_350.as_str());
}
}
array_349.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_aggregate_resource_identifier(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AggregateResourceIdentifier,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_351) = &input.source_account_id {
object.key("SourceAccountId").string(var_351.as_str());
}
if let Some(var_352) = &input.source_region {
object.key("SourceRegion").string(var_352.as_str());
}
if let Some(var_353) = &input.resource_id {
object.key("ResourceId").string(var_353.as_str());
}
if let Some(var_354) = &input.resource_type {
object.key("ResourceType").string(var_354.as_str());
}
if let Some(var_355) = &input.resource_name {
object.key("ResourceName").string(var_355.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_key(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceKey,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_356) = &input.resource_type {
object.key("resourceType").string(var_356.as_str());
}
if let Some(var_357) = &input.resource_id {
object.key("resourceId").string(var_357.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_remediation_exception_resource_key(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RemediationExceptionResourceKey,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_358) = &input.resource_type {
object.key("ResourceType").string(var_358.as_str());
}
if let Some(var_359) = &input.resource_id {
object.key("ResourceId").string(var_359.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_config_rule_compliance_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConfigRuleComplianceFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_360) = &input.config_rule_name {
object.key("ConfigRuleName").string(var_360.as_str());
}
if let Some(var_361) = &input.compliance_type {
object.key("ComplianceType").string(var_361.as_str());
}
if let Some(var_362) = &input.account_id {
object.key("AccountId").string(var_362.as_str());
}
if let Some(var_363) = &input.aws_region {
object.key("AwsRegion").string(var_363.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aggregate_conformance_pack_compliance_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AggregateConformancePackComplianceFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_364) = &input.conformance_pack_name {
object.key("ConformancePackName").string(var_364.as_str());
}
if let Some(var_365) = &input.compliance_type {
object.key("ComplianceType").string(var_365.as_str());
}
if let Some(var_366) = &input.account_id {
object.key("AccountId").string(var_366.as_str());
}
if let Some(var_367) = &input.aws_region {
object.key("AwsRegion").string(var_367.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_describe_config_rules_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DescribeConfigRulesFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_368) = &input.evaluation_mode {
object.key("EvaluationMode").string(var_368.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_conformance_pack_compliance_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConformancePackComplianceFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_369) = &input.config_rule_names {
let mut array_370 = object.key("ConfigRuleNames").start_array();
for item_371 in var_369 {
{
array_370.value().string(item_371.as_str());
}
}
array_370.finish();
}
if let Some(var_372) = &input.compliance_type {
object.key("ComplianceType").string(var_372.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_config_rule_compliance_summary_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConfigRuleComplianceSummaryFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_373) = &input.account_id {
object.key("AccountId").string(var_373.as_str());
}
if let Some(var_374) = &input.aws_region {
object.key("AwsRegion").string(var_374.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aggregate_conformance_pack_compliance_summary_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AggregateConformancePackComplianceSummaryFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_375) = &input.account_id {
object.key("AccountId").string(var_375.as_str());
}
if let Some(var_376) = &input.aws_region {
object.key("AwsRegion").string(var_376.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_count_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceCountFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_377) = &input.resource_type {
object.key("ResourceType").string(var_377.as_str());
}
if let Some(var_378) = &input.account_id {
object.key("AccountId").string(var_378.as_str());
}
if let Some(var_379) = &input.region {
object.key("Region").string(var_379.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_conformance_pack_evaluation_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConformancePackEvaluationFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_380) = &input.config_rule_names {
let mut array_381 = object.key("ConfigRuleNames").start_array();
for item_382 in var_380 {
{
array_381.value().string(item_382.as_str());
}
}
array_381.finish();
}
if let Some(var_383) = &input.compliance_type {
object.key("ComplianceType").string(var_383.as_str());
}
if let Some(var_384) = &input.resource_type {
object.key("ResourceType").string(var_384.as_str());
}
if let Some(var_385) = &input.resource_ids {
let mut array_386 = object.key("ResourceIds").start_array();
for item_387 in var_385 {
{
array_386.value().string(item_387.as_str());
}
}
array_386.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_status_detail_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StatusDetailFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_388) = &input.account_id {
object.key("AccountId").string(var_388.as_str());
}
if let Some(var_389) = &input.member_account_rule_status {
object
.key("MemberAccountRuleStatus")
.string(var_389.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_organization_resource_detailed_status_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OrganizationResourceDetailedStatusFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_390) = &input.account_id {
object.key("AccountId").string(var_390.as_str());
}
if let Some(var_391) = &input.status {
object.key("Status").string(var_391.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_392) = &input.account_id {
object.key("AccountId").string(var_392.as_str());
}
if let Some(var_393) = &input.resource_id {
object.key("ResourceId").string(var_393.as_str());
}
if let Some(var_394) = &input.resource_name {
object.key("ResourceName").string(var_394.as_str());
}
if let Some(var_395) = &input.region {
object.key("Region").string(var_395.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_conformance_pack_compliance_scores_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConformancePackComplianceScoresFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_396) = &input.conformance_pack_names {
let mut array_397 = object.key("ConformancePackNames").start_array();
for item_398 in var_396 {
{
array_397.value().string(item_398.as_str());
}
}
array_397.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_evaluation_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceEvaluationFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_399) = &input.evaluation_mode {
object.key("EvaluationMode").string(var_399.as_str());
}
if let Some(var_400) = &input.time_window {
#[allow(unused_mut)]
let mut object_401 = object.key("TimeWindow").start_object();
crate::json_ser::serialize_structure_crate_model_time_window(&mut object_401, var_400)?;
object_401.finish();
}
if let Some(var_402) = &input.evaluation_context_identifier {
object
.key("EvaluationContextIdentifier")
.string(var_402.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_403) = &input.key {
object.key("Key").string(var_403.as_str());
}
if let Some(var_404) = &input.value {
object.key("Value").string(var_404.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_config_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConfigRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_405) = &input.config_rule_name {
object.key("ConfigRuleName").string(var_405.as_str());
}
if let Some(var_406) = &input.config_rule_arn {
object.key("ConfigRuleArn").string(var_406.as_str());
}
if let Some(var_407) = &input.config_rule_id {
object.key("ConfigRuleId").string(var_407.as_str());
}
if let Some(var_408) = &input.description {
object.key("Description").string(var_408.as_str());
}
if let Some(var_409) = &input.scope {
#[allow(unused_mut)]
let mut object_410 = object.key("Scope").start_object();
crate::json_ser::serialize_structure_crate_model_scope(&mut object_410, var_409)?;
object_410.finish();
}
if let Some(var_411) = &input.source {
#[allow(unused_mut)]
let mut object_412 = object.key("Source").start_object();
crate::json_ser::serialize_structure_crate_model_source(&mut object_412, var_411)?;
object_412.finish();
}
if let Some(var_413) = &input.input_parameters {
object.key("InputParameters").string(var_413.as_str());
}
if let Some(var_414) = &input.maximum_execution_frequency {
object
.key("MaximumExecutionFrequency")
.string(var_414.as_str());
}
if let Some(var_415) = &input.config_rule_state {
object.key("ConfigRuleState").string(var_415.as_str());
}
if let Some(var_416) = &input.created_by {
object.key("CreatedBy").string(var_416.as_str());
}
if let Some(var_417) = &input.evaluation_modes {
let mut array_418 = object.key("EvaluationModes").start_array();
for item_419 in var_417 {
{
#[allow(unused_mut)]
let mut object_420 = array_418.value().start_object();
crate::json_ser::serialize_structure_crate_model_evaluation_mode_configuration(
&mut object_420,
item_419,
)?;
object_420.finish();
}
}
array_418.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_account_aggregation_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AccountAggregationSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_421) = &input.account_ids {
let mut array_422 = object.key("AccountIds").start_array();
for item_423 in var_421 {
{
array_422.value().string(item_423.as_str());
}
}
array_422.finish();
}
if input.all_aws_regions {
object.key("AllAwsRegions").boolean(input.all_aws_regions);
}
if let Some(var_424) = &input.aws_regions {
let mut array_425 = object.key("AwsRegions").start_array();
for item_426 in var_424 {
{
array_425.value().string(item_426.as_str());
}
}
array_425.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_organization_aggregation_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OrganizationAggregationSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_427) = &input.role_arn {
object.key("RoleArn").string(var_427.as_str());
}
if let Some(var_428) = &input.aws_regions {
let mut array_429 = object.key("AwsRegions").start_array();
for item_430 in var_428 {
{
array_429.value().string(item_430.as_str());
}
}
array_429.finish();
}
if input.all_aws_regions {
object.key("AllAwsRegions").boolean(input.all_aws_regions);
}
Ok(())
}
pub fn serialize_structure_crate_model_configuration_recorder(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConfigurationRecorder,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_431) = &input.name {
object.key("name").string(var_431.as_str());
}
if let Some(var_432) = &input.role_arn {
object.key("roleARN").string(var_432.as_str());
}
if let Some(var_433) = &input.recording_group {
#[allow(unused_mut)]
let mut object_434 = object.key("recordingGroup").start_object();
crate::json_ser::serialize_structure_crate_model_recording_group(&mut object_434, var_433)?;
object_434.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_conformance_pack_input_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConformancePackInputParameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_435) = &input.parameter_name {
object.key("ParameterName").string(var_435.as_str());
}
if let Some(var_436) = &input.parameter_value {
object.key("ParameterValue").string(var_436.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_template_ssm_document_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TemplateSsmDocumentDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_437) = &input.document_name {
object.key("DocumentName").string(var_437.as_str());
}
if let Some(var_438) = &input.document_version {
object.key("DocumentVersion").string(var_438.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_delivery_channel(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeliveryChannel,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_439) = &input.name {
object.key("name").string(var_439.as_str());
}
if let Some(var_440) = &input.s3_bucket_name {
object.key("s3BucketName").string(var_440.as_str());
}
if let Some(var_441) = &input.s3_key_prefix {
object.key("s3KeyPrefix").string(var_441.as_str());
}
if let Some(var_442) = &input.s3_kms_key_arn {
object.key("s3KmsKeyArn").string(var_442.as_str());
}
if let Some(var_443) = &input.sns_topic_arn {
object.key("snsTopicARN").string(var_443.as_str());
}
if let Some(var_444) = &input.config_snapshot_delivery_properties {
#[allow(unused_mut)]
let mut object_445 = object
.key("configSnapshotDeliveryProperties")
.start_object();
crate::json_ser::serialize_structure_crate_model_config_snapshot_delivery_properties(
&mut object_445,
var_444,
)?;
object_445.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_evaluation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Evaluation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_446) = &input.compliance_resource_type {
object
.key("ComplianceResourceType")
.string(var_446.as_str());
}
if let Some(var_447) = &input.compliance_resource_id {
object.key("ComplianceResourceId").string(var_447.as_str());
}
if let Some(var_448) = &input.compliance_type {
object.key("ComplianceType").string(var_448.as_str());
}
if let Some(var_449) = &input.annotation {
object.key("Annotation").string(var_449.as_str());
}
if let Some(var_450) = &input.ordering_timestamp {
object
.key("OrderingTimestamp")
.date_time(var_450, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_external_evaluation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExternalEvaluation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_451) = &input.compliance_resource_type {
object
.key("ComplianceResourceType")
.string(var_451.as_str());
}
if let Some(var_452) = &input.compliance_resource_id {
object.key("ComplianceResourceId").string(var_452.as_str());
}
if let Some(var_453) = &input.compliance_type {
object.key("ComplianceType").string(var_453.as_str());
}
if let Some(var_454) = &input.annotation {
object.key("Annotation").string(var_454.as_str());
}
if let Some(var_455) = &input.ordering_timestamp {
object
.key("OrderingTimestamp")
.date_time(var_455, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_organization_managed_rule_metadata(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OrganizationManagedRuleMetadata,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_456) = &input.description {
object.key("Description").string(var_456.as_str());
}
if let Some(var_457) = &input.rule_identifier {
object.key("RuleIdentifier").string(var_457.as_str());
}
if let Some(var_458) = &input.input_parameters {
object.key("InputParameters").string(var_458.as_str());
}
if let Some(var_459) = &input.maximum_execution_frequency {
object
.key("MaximumExecutionFrequency")
.string(var_459.as_str());
}
if let Some(var_460) = &input.resource_types_scope {
let mut array_461 = object.key("ResourceTypesScope").start_array();
for item_462 in var_460 {
{
array_461.value().string(item_462.as_str());
}
}
array_461.finish();
}
if let Some(var_463) = &input.resource_id_scope {
object.key("ResourceIdScope").string(var_463.as_str());
}
if let Some(var_464) = &input.tag_key_scope {
object.key("TagKeyScope").string(var_464.as_str());
}
if let Some(var_465) = &input.tag_value_scope {
object.key("TagValueScope").string(var_465.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_organization_custom_rule_metadata(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OrganizationCustomRuleMetadata,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_466) = &input.description {
object.key("Description").string(var_466.as_str());
}
if let Some(var_467) = &input.lambda_function_arn {
object.key("LambdaFunctionArn").string(var_467.as_str());
}
if let Some(var_468) = &input.organization_config_rule_trigger_types {
let mut array_469 = object
.key("OrganizationConfigRuleTriggerTypes")
.start_array();
for item_470 in var_468 {
{
array_469.value().string(item_470.as_str());
}
}
array_469.finish();
}
if let Some(var_471) = &input.input_parameters {
object.key("InputParameters").string(var_471.as_str());
}
if let Some(var_472) = &input.maximum_execution_frequency {
object
.key("MaximumExecutionFrequency")
.string(var_472.as_str());
}
if let Some(var_473) = &input.resource_types_scope {
let mut array_474 = object.key("ResourceTypesScope").start_array();
for item_475 in var_473 {
{
array_474.value().string(item_475.as_str());
}
}
array_474.finish();
}
if let Some(var_476) = &input.resource_id_scope {
object.key("ResourceIdScope").string(var_476.as_str());
}
if let Some(var_477) = &input.tag_key_scope {
object.key("TagKeyScope").string(var_477.as_str());
}
if let Some(var_478) = &input.tag_value_scope {
object.key("TagValueScope").string(var_478.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_organization_custom_policy_rule_metadata(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OrganizationCustomPolicyRuleMetadata,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_479) = &input.description {
object.key("Description").string(var_479.as_str());
}
if let Some(var_480) = &input.organization_config_rule_trigger_types {
let mut array_481 = object
.key("OrganizationConfigRuleTriggerTypes")
.start_array();
for item_482 in var_480 {
{
array_481.value().string(item_482.as_str());
}
}
array_481.finish();
}
if let Some(var_483) = &input.input_parameters {
object.key("InputParameters").string(var_483.as_str());
}
if let Some(var_484) = &input.maximum_execution_frequency {
object
.key("MaximumExecutionFrequency")
.string(var_484.as_str());
}
if let Some(var_485) = &input.resource_types_scope {
let mut array_486 = object.key("ResourceTypesScope").start_array();
for item_487 in var_485 {
{
array_486.value().string(item_487.as_str());
}
}
array_486.finish();
}
if let Some(var_488) = &input.resource_id_scope {
object.key("ResourceIdScope").string(var_488.as_str());
}
if let Some(var_489) = &input.tag_key_scope {
object.key("TagKeyScope").string(var_489.as_str());
}
if let Some(var_490) = &input.tag_value_scope {
object.key("TagValueScope").string(var_490.as_str());
}
if let Some(var_491) = &input.policy_runtime {
object.key("PolicyRuntime").string(var_491.as_str());
}
if let Some(var_492) = &input.policy_text {
object.key("PolicyText").string(var_492.as_str());
}
if let Some(var_493) = &input.debug_log_delivery_accounts {
let mut array_494 = object.key("DebugLogDeliveryAccounts").start_array();
for item_495 in var_493 {
{
array_494.value().string(item_495.as_str());
}
}
array_494.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_remediation_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RemediationConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_496) = &input.config_rule_name {
object.key("ConfigRuleName").string(var_496.as_str());
}
if let Some(var_497) = &input.target_type {
object.key("TargetType").string(var_497.as_str());
}
if let Some(var_498) = &input.target_id {
object.key("TargetId").string(var_498.as_str());
}
if let Some(var_499) = &input.target_version {
object.key("TargetVersion").string(var_499.as_str());
}
if let Some(var_500) = &input.parameters {
#[allow(unused_mut)]
let mut object_501 = object.key("Parameters").start_object();
for (key_502, value_503) in var_500 {
{
#[allow(unused_mut)]
let mut object_504 = object_501.key(key_502.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_remediation_parameter_value(
&mut object_504,
value_503,
)?;
object_504.finish();
}
}
object_501.finish();
}
if let Some(var_505) = &input.resource_type {
object.key("ResourceType").string(var_505.as_str());
}
if input.automatic {
object.key("Automatic").boolean(input.automatic);
}
if let Some(var_506) = &input.execution_controls {
#[allow(unused_mut)]
let mut object_507 = object.key("ExecutionControls").start_object();
crate::json_ser::serialize_structure_crate_model_execution_controls(
&mut object_507,
var_506,
)?;
object_507.finish();
}
if let Some(var_508) = &input.maximum_automatic_attempts {
object.key("MaximumAutomaticAttempts").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_508).into()),
);
}
if let Some(var_509) = &input.retry_attempt_seconds {
object.key("RetryAttemptSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_509).into()),
);
}
if let Some(var_510) = &input.arn {
object.key("Arn").string(var_510.as_str());
}
if let Some(var_511) = &input.created_by_service {
object.key("CreatedByService").string(var_511.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_stored_query(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StoredQuery,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_512) = &input.query_id {
object.key("QueryId").string(var_512.as_str());
}
if let Some(var_513) = &input.query_arn {
object.key("QueryArn").string(var_513.as_str());
}
if let Some(var_514) = &input.query_name {
object.key("QueryName").string(var_514.as_str());
}
if let Some(var_515) = &input.description {
object.key("Description").string(var_515.as_str());
}
if let Some(var_516) = &input.expression {
object.key("Expression").string(var_516.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_517) = &input.resource_id {
object.key("ResourceId").string(var_517.as_str());
}
if let Some(var_518) = &input.resource_type {
object.key("ResourceType").string(var_518.as_str());
}
if let Some(var_519) = &input.resource_configuration {
object.key("ResourceConfiguration").string(var_519.as_str());
}
if let Some(var_520) = &input.resource_configuration_schema_type {
object
.key("ResourceConfigurationSchemaType")
.string(var_520.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_evaluation_context(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EvaluationContext,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_521) = &input.evaluation_context_identifier {
object
.key("EvaluationContextIdentifier")
.string(var_521.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_time_window(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimeWindow,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_522) = &input.start_time {
object
.key("StartTime")
.date_time(var_522, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_523) = &input.end_time {
object
.key("EndTime")
.date_time(var_523, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_scope(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Scope,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_524) = &input.compliance_resource_types {
let mut array_525 = object.key("ComplianceResourceTypes").start_array();
for item_526 in var_524 {
{
array_525.value().string(item_526.as_str());
}
}
array_525.finish();
}
if let Some(var_527) = &input.tag_key {
object.key("TagKey").string(var_527.as_str());
}
if let Some(var_528) = &input.tag_value {
object.key("TagValue").string(var_528.as_str());
}
if let Some(var_529) = &input.compliance_resource_id {
object.key("ComplianceResourceId").string(var_529.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Source,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_530) = &input.owner {
object.key("Owner").string(var_530.as_str());
}
if let Some(var_531) = &input.source_identifier {
object.key("SourceIdentifier").string(var_531.as_str());
}
if let Some(var_532) = &input.source_details {
let mut array_533 = object.key("SourceDetails").start_array();
for item_534 in var_532 {
{
#[allow(unused_mut)]
let mut object_535 = array_533.value().start_object();
crate::json_ser::serialize_structure_crate_model_source_detail(
&mut object_535,
item_534,
)?;
object_535.finish();
}
}
array_533.finish();
}
if let Some(var_536) = &input.custom_policy_details {
#[allow(unused_mut)]
let mut object_537 = object.key("CustomPolicyDetails").start_object();
crate::json_ser::serialize_structure_crate_model_custom_policy_details(
&mut object_537,
var_536,
)?;
object_537.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_evaluation_mode_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EvaluationModeConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_538) = &input.mode {
object.key("Mode").string(var_538.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_recording_group(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RecordingGroup,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.all_supported {
object.key("allSupported").boolean(input.all_supported);
}
if input.include_global_resource_types {
object
.key("includeGlobalResourceTypes")
.boolean(input.include_global_resource_types);
}
if let Some(var_539) = &input.resource_types {
let mut array_540 = object.key("resourceTypes").start_array();
for item_541 in var_539 {
{
array_540.value().string(item_541.as_str());
}
}
array_540.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_config_snapshot_delivery_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConfigSnapshotDeliveryProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_542) = &input.delivery_frequency {
object.key("deliveryFrequency").string(var_542.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_remediation_parameter_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RemediationParameterValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_543) = &input.resource_value {
#[allow(unused_mut)]
let mut object_544 = object.key("ResourceValue").start_object();
crate::json_ser::serialize_structure_crate_model_resource_value(&mut object_544, var_543)?;
object_544.finish();
}
if let Some(var_545) = &input.static_value {
#[allow(unused_mut)]
let mut object_546 = object.key("StaticValue").start_object();
crate::json_ser::serialize_structure_crate_model_static_value(&mut object_546, var_545)?;
object_546.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_execution_controls(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExecutionControls,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_547) = &input.ssm_controls {
#[allow(unused_mut)]
let mut object_548 = object.key("SsmControls").start_object();
crate::json_ser::serialize_structure_crate_model_ssm_controls(&mut object_548, var_547)?;
object_548.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_source_detail(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SourceDetail,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_549) = &input.event_source {
object.key("EventSource").string(var_549.as_str());
}
if let Some(var_550) = &input.message_type {
object.key("MessageType").string(var_550.as_str());
}
if let Some(var_551) = &input.maximum_execution_frequency {
object
.key("MaximumExecutionFrequency")
.string(var_551.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_policy_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomPolicyDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_552) = &input.policy_runtime {
object.key("PolicyRuntime").string(var_552.as_str());
}
if let Some(var_553) = &input.policy_text {
object.key("PolicyText").string(var_553.as_str());
}
if input.enable_debug_log_delivery {
object
.key("EnableDebugLogDelivery")
.boolean(input.enable_debug_log_delivery);
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_554) = &input.value {
object.key("Value").string(var_554.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_static_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StaticValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_555) = &input.values {
let mut array_556 = object.key("Values").start_array();
for item_557 in var_555 {
{
array_556.value().string(item_557.as_str());
}
}
array_556.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_ssm_controls(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SsmControls,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_558) = &input.concurrent_execution_rate_percentage {
object.key("ConcurrentExecutionRatePercentage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_558).into()),
);
}
if let Some(var_559) = &input.error_percentage {
object.key("ErrorPercentage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_559).into()),
);
}
Ok(())
}