pub fn serialize_structure_crate_input_accept_invitation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AcceptInvitationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.administrator_account_id {
object.key("administratorAccountId").string(var_1.as_str());
}
if let Some(var_2) = &input.invitation_id {
object.key("invitationId").string(var_2.as_str());
}
if let Some(var_3) = &input.master_account {
object.key("masterAccount").string(var_3.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_get_custom_data_identifiers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetCustomDataIdentifiersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_4) = &input.ids {
let mut array_5 = object.key("ids").start_array();
for item_6 in var_4 {
{
array_5.value().string(item_6.as_str());
}
}
array_5.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_allow_list_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAllowListInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_7) = &input.client_token {
object.key("clientToken").string(var_7.as_str());
}
if let Some(var_8) = &input.criteria {
#[allow(unused_mut)]
let mut object_9 = object.key("criteria").start_object();
crate::json_ser::serialize_structure_crate_model_allow_list_criteria(&mut object_9, var_8)?;
object_9.finish();
}
if let Some(var_10) = &input.description {
object.key("description").string(var_10.as_str());
}
if let Some(var_11) = &input.name {
object.key("name").string(var_11.as_str());
}
if let Some(var_12) = &input.tags {
#[allow(unused_mut)]
let mut object_13 = object.key("tags").start_object();
for (key_14, value_15) in var_12 {
{
object_13.key(key_14.as_str()).string(value_15.as_str());
}
}
object_13.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_classification_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateClassificationJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_16) = &input.allow_list_ids {
let mut array_17 = object.key("allowListIds").start_array();
for item_18 in var_16 {
{
array_17.value().string(item_18.as_str());
}
}
array_17.finish();
}
if let Some(var_19) = &input.client_token {
object.key("clientToken").string(var_19.as_str());
}
if let Some(var_20) = &input.custom_data_identifier_ids {
let mut array_21 = object.key("customDataIdentifierIds").start_array();
for item_22 in var_20 {
{
array_21.value().string(item_22.as_str());
}
}
array_21.finish();
}
if let Some(var_23) = &input.description {
object.key("description").string(var_23.as_str());
}
if input.initial_run {
object.key("initialRun").boolean(input.initial_run);
}
if let Some(var_24) = &input.job_type {
object.key("jobType").string(var_24.as_str());
}
if let Some(var_25) = &input.managed_data_identifier_ids {
let mut array_26 = object.key("managedDataIdentifierIds").start_array();
for item_27 in var_25 {
{
array_26.value().string(item_27.as_str());
}
}
array_26.finish();
}
if let Some(var_28) = &input.managed_data_identifier_selector {
object
.key("managedDataIdentifierSelector")
.string(var_28.as_str());
}
if let Some(var_29) = &input.name {
object.key("name").string(var_29.as_str());
}
if let Some(var_30) = &input.s3_job_definition {
#[allow(unused_mut)]
let mut object_31 = object.key("s3JobDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_s3_job_definition(&mut object_31, var_30)?;
object_31.finish();
}
if input.sampling_percentage != 0 {
object.key("samplingPercentage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.sampling_percentage).into()),
);
}
if let Some(var_32) = &input.schedule_frequency {
#[allow(unused_mut)]
let mut object_33 = object.key("scheduleFrequency").start_object();
crate::json_ser::serialize_structure_crate_model_job_schedule_frequency(
&mut object_33,
var_32,
)?;
object_33.finish();
}
if let Some(var_34) = &input.tags {
#[allow(unused_mut)]
let mut object_35 = object.key("tags").start_object();
for (key_36, value_37) in var_34 {
{
object_35.key(key_36.as_str()).string(value_37.as_str());
}
}
object_35.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_custom_data_identifier_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateCustomDataIdentifierInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_38) = &input.client_token {
object.key("clientToken").string(var_38.as_str());
}
if let Some(var_39) = &input.description {
object.key("description").string(var_39.as_str());
}
if let Some(var_40) = &input.ignore_words {
let mut array_41 = object.key("ignoreWords").start_array();
for item_42 in var_40 {
{
array_41.value().string(item_42.as_str());
}
}
array_41.finish();
}
if let Some(var_43) = &input.keywords {
let mut array_44 = object.key("keywords").start_array();
for item_45 in var_43 {
{
array_44.value().string(item_45.as_str());
}
}
array_44.finish();
}
if input.maximum_match_distance != 0 {
object.key("maximumMatchDistance").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.maximum_match_distance).into()),
);
}
if let Some(var_46) = &input.name {
object.key("name").string(var_46.as_str());
}
if let Some(var_47) = &input.regex {
object.key("regex").string(var_47.as_str());
}
if let Some(var_48) = &input.severity_levels {
let mut array_49 = object.key("severityLevels").start_array();
for item_50 in var_48 {
{
#[allow(unused_mut)]
let mut object_51 = array_49.value().start_object();
crate::json_ser::serialize_structure_crate_model_severity_level(
&mut object_51,
item_50,
)?;
object_51.finish();
}
}
array_49.finish();
}
if let Some(var_52) = &input.tags {
#[allow(unused_mut)]
let mut object_53 = object.key("tags").start_object();
for (key_54, value_55) in var_52 {
{
object_53.key(key_54.as_str()).string(value_55.as_str());
}
}
object_53.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_findings_filter_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFindingsFilterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_56) = &input.action {
object.key("action").string(var_56.as_str());
}
if let Some(var_57) = &input.client_token {
object.key("clientToken").string(var_57.as_str());
}
if let Some(var_58) = &input.description {
object.key("description").string(var_58.as_str());
}
if let Some(var_59) = &input.finding_criteria {
#[allow(unused_mut)]
let mut object_60 = object.key("findingCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_finding_criteria(&mut object_60, var_59)?;
object_60.finish();
}
if let Some(var_61) = &input.name {
object.key("name").string(var_61.as_str());
}
if input.position != 0 {
object.key("position").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.position).into()),
);
}
if let Some(var_62) = &input.tags {
#[allow(unused_mut)]
let mut object_63 = object.key("tags").start_object();
for (key_64, value_65) in var_62 {
{
object_63.key(key_64.as_str()).string(value_65.as_str());
}
}
object_63.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_invitations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateInvitationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_66) = &input.account_ids {
let mut array_67 = object.key("accountIds").start_array();
for item_68 in var_66 {
{
array_67.value().string(item_68.as_str());
}
}
array_67.finish();
}
if input.disable_email_notification {
object
.key("disableEmailNotification")
.boolean(input.disable_email_notification);
}
if let Some(var_69) = &input.message {
object.key("message").string(var_69.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_member_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateMemberInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.account {
#[allow(unused_mut)]
let mut object_71 = object.key("account").start_object();
crate::json_ser::serialize_structure_crate_model_account_detail(&mut object_71, var_70)?;
object_71.finish();
}
if let Some(var_72) = &input.tags {
#[allow(unused_mut)]
let mut object_73 = object.key("tags").start_object();
for (key_74, value_75) in var_72 {
{
object_73.key(key_74.as_str()).string(value_75.as_str());
}
}
object_73.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_sample_findings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSampleFindingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_76) = &input.finding_types {
let mut array_77 = object.key("findingTypes").start_array();
for item_78 in var_76 {
{
array_77.value().string(item_78.as_str());
}
}
array_77.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_decline_invitations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeclineInvitationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_79) = &input.account_ids {
let mut array_80 = object.key("accountIds").start_array();
for item_81 in var_79 {
{
array_80.value().string(item_81.as_str());
}
}
array_80.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_invitations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteInvitationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_82) = &input.account_ids {
let mut array_83 = object.key("accountIds").start_array();
for item_84 in var_82 {
{
array_83.value().string(item_84.as_str());
}
}
array_83.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_buckets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeBucketsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.criteria {
#[allow(unused_mut)]
let mut object_86 = object.key("criteria").start_object();
for (key_87, value_88) in var_85 {
{
#[allow(unused_mut)]
let mut object_89 = object_86.key(key_87.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_bucket_criteria_additional_properties(&mut object_89, value_88)?;
object_89.finish();
}
}
object_86.finish();
}
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_90) = &input.next_token {
object.key("nextToken").string(var_90.as_str());
}
if let Some(var_91) = &input.sort_criteria {
#[allow(unused_mut)]
let mut object_92 = object.key("sortCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_bucket_sort_criteria(
&mut object_92,
var_91,
)?;
object_92.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_enable_macie_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::EnableMacieInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.client_token {
object.key("clientToken").string(var_93.as_str());
}
if let Some(var_94) = &input.finding_publishing_frequency {
object
.key("findingPublishingFrequency")
.string(var_94.as_str());
}
if let Some(var_95) = &input.status {
object.key("status").string(var_95.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_enable_organization_admin_account_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::EnableOrganizationAdminAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_96) = &input.admin_account_id {
object.key("adminAccountId").string(var_96.as_str());
}
if let Some(var_97) = &input.client_token {
object.key("clientToken").string(var_97.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_bucket_statistics_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetBucketStatisticsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_98) = &input.account_id {
object.key("accountId").string(var_98.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_findings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetFindingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_99) = &input.finding_ids {
let mut array_100 = object.key("findingIds").start_array();
for item_101 in var_99 {
{
array_100.value().string(item_101.as_str());
}
}
array_100.finish();
}
if let Some(var_102) = &input.sort_criteria {
#[allow(unused_mut)]
let mut object_103 = object.key("sortCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_sort_criteria(&mut object_103, var_102)?;
object_103.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_finding_statistics_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetFindingStatisticsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_104) = &input.finding_criteria {
#[allow(unused_mut)]
let mut object_105 = object.key("findingCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_finding_criteria(
&mut object_105,
var_104,
)?;
object_105.finish();
}
if let Some(var_106) = &input.group_by {
object.key("groupBy").string(var_106.as_str());
}
if input.size != 0 {
object.key("size").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.size).into()),
);
}
if let Some(var_107) = &input.sort_criteria {
#[allow(unused_mut)]
let mut object_108 = object.key("sortCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_finding_statistics_sort_criteria(
&mut object_108,
var_107,
)?;
object_108.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_usage_statistics_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetUsageStatisticsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_109) = &input.filter_by {
let mut array_110 = object.key("filterBy").start_array();
for item_111 in var_109 {
{
#[allow(unused_mut)]
let mut object_112 = array_110.value().start_object();
crate::json_ser::serialize_structure_crate_model_usage_statistics_filter(
&mut object_112,
item_111,
)?;
object_112.finish();
}
}
array_110.finish();
}
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_113) = &input.next_token {
object.key("nextToken").string(var_113.as_str());
}
if let Some(var_114) = &input.sort_by {
#[allow(unused_mut)]
let mut object_115 = object.key("sortBy").start_object();
crate::json_ser::serialize_structure_crate_model_usage_statistics_sort_by(
&mut object_115,
var_114,
)?;
object_115.finish();
}
if let Some(var_116) = &input.time_range {
object.key("timeRange").string(var_116.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_classification_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListClassificationJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_117) = &input.filter_criteria {
#[allow(unused_mut)]
let mut object_118 = object.key("filterCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_list_jobs_filter_criteria(
&mut object_118,
var_117,
)?;
object_118.finish();
}
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_119) = &input.next_token {
object.key("nextToken").string(var_119.as_str());
}
if let Some(var_120) = &input.sort_criteria {
#[allow(unused_mut)]
let mut object_121 = object.key("sortCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_list_jobs_sort_criteria(
&mut object_121,
var_120,
)?;
object_121.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_custom_data_identifiers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListCustomDataIdentifiersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
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_122) = &input.next_token {
object.key("nextToken").string(var_122.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_findings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListFindingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_123) = &input.finding_criteria {
#[allow(unused_mut)]
let mut object_124 = object.key("findingCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_finding_criteria(
&mut object_124,
var_123,
)?;
object_124.finish();
}
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_125) = &input.next_token {
object.key("nextToken").string(var_125.as_str());
}
if let Some(var_126) = &input.sort_criteria {
#[allow(unused_mut)]
let mut object_127 = object.key("sortCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_sort_criteria(&mut object_127, var_126)?;
object_127.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_managed_data_identifiers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListManagedDataIdentifiersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_128) = &input.next_token {
object.key("nextToken").string(var_128.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_classification_export_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutClassificationExportConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_129) = &input.configuration {
#[allow(unused_mut)]
let mut object_130 = object.key("configuration").start_object();
crate::json_ser::serialize_structure_crate_model_classification_export_configuration(
&mut object_130,
var_129,
)?;
object_130.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_findings_publication_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutFindingsPublicationConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_131) = &input.client_token {
object.key("clientToken").string(var_131.as_str());
}
if let Some(var_132) = &input.security_hub_configuration {
#[allow(unused_mut)]
let mut object_133 = object.key("securityHubConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_security_hub_configuration(
&mut object_133,
var_132,
)?;
object_133.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_search_resources_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchResourcesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_134) = &input.bucket_criteria {
#[allow(unused_mut)]
let mut object_135 = object.key("bucketCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_search_resources_bucket_criteria(
&mut object_135,
var_134,
)?;
object_135.finish();
}
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_136) = &input.next_token {
object.key("nextToken").string(var_136.as_str());
}
if let Some(var_137) = &input.sort_criteria {
#[allow(unused_mut)]
let mut object_138 = object.key("sortCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_search_resources_sort_criteria(
&mut object_138,
var_137,
)?;
object_138.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_139) = &input.tags {
#[allow(unused_mut)]
let mut object_140 = object.key("tags").start_object();
for (key_141, value_142) in var_139 {
{
object_140.key(key_141.as_str()).string(value_142.as_str());
}
}
object_140.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_test_custom_data_identifier_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TestCustomDataIdentifierInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_143) = &input.ignore_words {
let mut array_144 = object.key("ignoreWords").start_array();
for item_145 in var_143 {
{
array_144.value().string(item_145.as_str());
}
}
array_144.finish();
}
if let Some(var_146) = &input.keywords {
let mut array_147 = object.key("keywords").start_array();
for item_148 in var_146 {
{
array_147.value().string(item_148.as_str());
}
}
array_147.finish();
}
if input.maximum_match_distance != 0 {
object.key("maximumMatchDistance").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.maximum_match_distance).into()),
);
}
if let Some(var_149) = &input.regex {
object.key("regex").string(var_149.as_str());
}
if let Some(var_150) = &input.sample_text {
object.key("sampleText").string(var_150.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_allow_list_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAllowListInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_151) = &input.criteria {
#[allow(unused_mut)]
let mut object_152 = object.key("criteria").start_object();
crate::json_ser::serialize_structure_crate_model_allow_list_criteria(
&mut object_152,
var_151,
)?;
object_152.finish();
}
if let Some(var_153) = &input.description {
object.key("description").string(var_153.as_str());
}
if let Some(var_154) = &input.name {
object.key("name").string(var_154.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_automated_discovery_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAutomatedDiscoveryConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_155) = &input.status {
object.key("status").string(var_155.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_classification_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateClassificationJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_156) = &input.job_status {
object.key("jobStatus").string(var_156.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_classification_scope_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateClassificationScopeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_157) = &input.s3 {
#[allow(unused_mut)]
let mut object_158 = object.key("s3").start_object();
crate::json_ser::serialize_structure_crate_model_s3_classification_scope_update(
&mut object_158,
var_157,
)?;
object_158.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_findings_filter_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFindingsFilterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_159) = &input.action {
object.key("action").string(var_159.as_str());
}
if let Some(var_160) = &input.client_token {
object.key("clientToken").string(var_160.as_str());
}
if let Some(var_161) = &input.description {
object.key("description").string(var_161.as_str());
}
if let Some(var_162) = &input.finding_criteria {
#[allow(unused_mut)]
let mut object_163 = object.key("findingCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_finding_criteria(
&mut object_163,
var_162,
)?;
object_163.finish();
}
if let Some(var_164) = &input.name {
object.key("name").string(var_164.as_str());
}
if input.position != 0 {
object.key("position").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.position).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_macie_session_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateMacieSessionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_165) = &input.finding_publishing_frequency {
object
.key("findingPublishingFrequency")
.string(var_165.as_str());
}
if let Some(var_166) = &input.status {
object.key("status").string(var_166.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_member_session_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateMemberSessionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_167) = &input.status {
object.key("status").string(var_167.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_organization_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateOrganizationConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("autoEnable").boolean(input.auto_enable);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_resource_profile_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateResourceProfileInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.sensitivity_score_override != 0 {
object.key("sensitivityScoreOverride").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.sensitivity_score_override).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_resource_profile_detections_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateResourceProfileDetectionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_168) = &input.suppress_data_identifiers {
let mut array_169 = object.key("suppressDataIdentifiers").start_array();
for item_170 in var_168 {
{
#[allow(unused_mut)]
let mut object_171 = array_169.value().start_object();
crate::json_ser::serialize_structure_crate_model_suppress_data_identifier(
&mut object_171,
item_170,
)?;
object_171.finish();
}
}
array_169.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_reveal_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRevealConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_172) = &input.configuration {
#[allow(unused_mut)]
let mut object_173 = object.key("configuration").start_object();
crate::json_ser::serialize_structure_crate_model_reveal_configuration(
&mut object_173,
var_172,
)?;
object_173.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_sensitivity_inspection_template_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSensitivityInspectionTemplateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_174) = &input.description {
object.key("description").string(var_174.as_str());
}
if let Some(var_175) = &input.excludes {
#[allow(unused_mut)]
let mut object_176 = object.key("excludes").start_object();
crate::json_ser::serialize_structure_crate_model_sensitivity_inspection_template_excludes(
&mut object_176,
var_175,
)?;
object_176.finish();
}
if let Some(var_177) = &input.includes {
#[allow(unused_mut)]
let mut object_178 = object.key("includes").start_object();
crate::json_ser::serialize_structure_crate_model_sensitivity_inspection_template_includes(
&mut object_178,
var_177,
)?;
object_178.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_allow_list_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AllowListCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_179) = &input.regex {
object.key("regex").string(var_179.as_str());
}
if let Some(var_180) = &input.s3_words_list {
#[allow(unused_mut)]
let mut object_181 = object.key("s3WordsList").start_object();
crate::json_ser::serialize_structure_crate_model_s3_words_list(&mut object_181, var_180)?;
object_181.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_job_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3JobDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_182) = &input.bucket_criteria {
#[allow(unused_mut)]
let mut object_183 = object.key("bucketCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_s3_bucket_criteria_for_job(
&mut object_183,
var_182,
)?;
object_183.finish();
}
if let Some(var_184) = &input.bucket_definitions {
let mut array_185 = object.key("bucketDefinitions").start_array();
for item_186 in var_184 {
{
#[allow(unused_mut)]
let mut object_187 = array_185.value().start_object();
crate::json_ser::serialize_structure_crate_model_s3_bucket_definition_for_job(
&mut object_187,
item_186,
)?;
object_187.finish();
}
}
array_185.finish();
}
if let Some(var_188) = &input.scoping {
#[allow(unused_mut)]
let mut object_189 = object.key("scoping").start_object();
crate::json_ser::serialize_structure_crate_model_scoping(&mut object_189, var_188)?;
object_189.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_job_schedule_frequency(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JobScheduleFrequency,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_190) = &input.daily_schedule {
#[allow(unused_mut)]
let mut object_191 = object.key("dailySchedule").start_object();
crate::json_ser::serialize_structure_crate_model_daily_schedule(&mut object_191, var_190)?;
object_191.finish();
}
if let Some(var_192) = &input.monthly_schedule {
#[allow(unused_mut)]
let mut object_193 = object.key("monthlySchedule").start_object();
crate::json_ser::serialize_structure_crate_model_monthly_schedule(
&mut object_193,
var_192,
)?;
object_193.finish();
}
if let Some(var_194) = &input.weekly_schedule {
#[allow(unused_mut)]
let mut object_195 = object.key("weeklySchedule").start_object();
crate::json_ser::serialize_structure_crate_model_weekly_schedule(&mut object_195, var_194)?;
object_195.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_severity_level(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SeverityLevel,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("occurrencesThreshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.occurrences_threshold).into()),
);
}
if let Some(var_196) = &input.severity {
object.key("severity").string(var_196.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_finding_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FindingCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_197) = &input.criterion {
#[allow(unused_mut)]
let mut object_198 = object.key("criterion").start_object();
for (key_199, value_200) in var_197 {
{
#[allow(unused_mut)]
let mut object_201 = object_198.key(key_199.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_criterion_additional_properties(
&mut object_201,
value_200,
)?;
object_201.finish();
}
}
object_198.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_account_detail(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AccountDetail,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_202) = &input.account_id {
object.key("accountId").string(var_202.as_str());
}
if let Some(var_203) = &input.email {
object.key("email").string(var_203.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_bucket_criteria_additional_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BucketCriteriaAdditionalProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_204) = &input.eq {
let mut array_205 = object.key("eq").start_array();
for item_206 in var_204 {
{
array_205.value().string(item_206.as_str());
}
}
array_205.finish();
}
if input.gt != 0 {
object.key("gt").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.gt).into()),
);
}
if input.gte != 0 {
object.key("gte").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.gte).into()),
);
}
if input.lt != 0 {
object.key("lt").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.lt).into()),
);
}
if input.lte != 0 {
object.key("lte").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.lte).into()),
);
}
if let Some(var_207) = &input.neq {
let mut array_208 = object.key("neq").start_array();
for item_209 in var_207 {
{
array_208.value().string(item_209.as_str());
}
}
array_208.finish();
}
if let Some(var_210) = &input.prefix {
object.key("prefix").string(var_210.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_bucket_sort_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BucketSortCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_211) = &input.attribute_name {
object.key("attributeName").string(var_211.as_str());
}
if let Some(var_212) = &input.order_by {
object.key("orderBy").string(var_212.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sort_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SortCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_213) = &input.attribute_name {
object.key("attributeName").string(var_213.as_str());
}
if let Some(var_214) = &input.order_by {
object.key("orderBy").string(var_214.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_finding_statistics_sort_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FindingStatisticsSortCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_215) = &input.attribute_name {
object.key("attributeName").string(var_215.as_str());
}
if let Some(var_216) = &input.order_by {
object.key("orderBy").string(var_216.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_usage_statistics_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UsageStatisticsFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_217) = &input.comparator {
object.key("comparator").string(var_217.as_str());
}
if let Some(var_218) = &input.key {
object.key("key").string(var_218.as_str());
}
if let Some(var_219) = &input.values {
let mut array_220 = object.key("values").start_array();
for item_221 in var_219 {
{
array_220.value().string(item_221.as_str());
}
}
array_220.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_usage_statistics_sort_by(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UsageStatisticsSortBy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_222) = &input.key {
object.key("key").string(var_222.as_str());
}
if let Some(var_223) = &input.order_by {
object.key("orderBy").string(var_223.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_list_jobs_filter_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListJobsFilterCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_224) = &input.excludes {
let mut array_225 = object.key("excludes").start_array();
for item_226 in var_224 {
{
#[allow(unused_mut)]
let mut object_227 = array_225.value().start_object();
crate::json_ser::serialize_structure_crate_model_list_jobs_filter_term(
&mut object_227,
item_226,
)?;
object_227.finish();
}
}
array_225.finish();
}
if let Some(var_228) = &input.includes {
let mut array_229 = object.key("includes").start_array();
for item_230 in var_228 {
{
#[allow(unused_mut)]
let mut object_231 = array_229.value().start_object();
crate::json_ser::serialize_structure_crate_model_list_jobs_filter_term(
&mut object_231,
item_230,
)?;
object_231.finish();
}
}
array_229.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_list_jobs_sort_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListJobsSortCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_232) = &input.attribute_name {
object.key("attributeName").string(var_232.as_str());
}
if let Some(var_233) = &input.order_by {
object.key("orderBy").string(var_233.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_classification_export_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ClassificationExportConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_234) = &input.s3_destination {
#[allow(unused_mut)]
let mut object_235 = object.key("s3Destination").start_object();
crate::json_ser::serialize_structure_crate_model_s3_destination(&mut object_235, var_234)?;
object_235.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_security_hub_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SecurityHubConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object
.key("publishClassificationFindings")
.boolean(input.publish_classification_findings);
}
{
object
.key("publishPolicyFindings")
.boolean(input.publish_policy_findings);
}
Ok(())
}
pub fn serialize_structure_crate_model_search_resources_bucket_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SearchResourcesBucketCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_236) = &input.excludes {
#[allow(unused_mut)]
let mut object_237 = object.key("excludes").start_object();
crate::json_ser::serialize_structure_crate_model_search_resources_criteria_block(
&mut object_237,
var_236,
)?;
object_237.finish();
}
if let Some(var_238) = &input.includes {
#[allow(unused_mut)]
let mut object_239 = object.key("includes").start_object();
crate::json_ser::serialize_structure_crate_model_search_resources_criteria_block(
&mut object_239,
var_238,
)?;
object_239.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_search_resources_sort_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SearchResourcesSortCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_240) = &input.attribute_name {
object.key("attributeName").string(var_240.as_str());
}
if let Some(var_241) = &input.order_by {
object.key("orderBy").string(var_241.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_classification_scope_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3ClassificationScopeUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_242) = &input.excludes {
#[allow(unused_mut)]
let mut object_243 = object.key("excludes").start_object();
crate::json_ser::serialize_structure_crate_model_s3_classification_scope_exclusion_update(
&mut object_243,
var_242,
)?;
object_243.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_suppress_data_identifier(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SuppressDataIdentifier,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_244) = &input.id {
object.key("id").string(var_244.as_str());
}
if let Some(var_245) = &input.r#type {
object.key("type").string(var_245.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_reveal_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RevealConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_246) = &input.kms_key_id {
object.key("kmsKeyId").string(var_246.as_str());
}
if let Some(var_247) = &input.status {
object.key("status").string(var_247.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sensitivity_inspection_template_excludes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SensitivityInspectionTemplateExcludes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_248) = &input.managed_data_identifier_ids {
let mut array_249 = object.key("managedDataIdentifierIds").start_array();
for item_250 in var_248 {
{
array_249.value().string(item_250.as_str());
}
}
array_249.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sensitivity_inspection_template_includes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SensitivityInspectionTemplateIncludes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_251) = &input.allow_list_ids {
let mut array_252 = object.key("allowListIds").start_array();
for item_253 in var_251 {
{
array_252.value().string(item_253.as_str());
}
}
array_252.finish();
}
if let Some(var_254) = &input.custom_data_identifier_ids {
let mut array_255 = object.key("customDataIdentifierIds").start_array();
for item_256 in var_254 {
{
array_255.value().string(item_256.as_str());
}
}
array_255.finish();
}
if let Some(var_257) = &input.managed_data_identifier_ids {
let mut array_258 = object.key("managedDataIdentifierIds").start_array();
for item_259 in var_257 {
{
array_258.value().string(item_259.as_str());
}
}
array_258.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_words_list(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3WordsList,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_260) = &input.bucket_name {
object.key("bucketName").string(var_260.as_str());
}
if let Some(var_261) = &input.object_key {
object.key("objectKey").string(var_261.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_bucket_criteria_for_job(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3BucketCriteriaForJob,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_262) = &input.excludes {
#[allow(unused_mut)]
let mut object_263 = object.key("excludes").start_object();
crate::json_ser::serialize_structure_crate_model_criteria_block_for_job(
&mut object_263,
var_262,
)?;
object_263.finish();
}
if let Some(var_264) = &input.includes {
#[allow(unused_mut)]
let mut object_265 = object.key("includes").start_object();
crate::json_ser::serialize_structure_crate_model_criteria_block_for_job(
&mut object_265,
var_264,
)?;
object_265.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_bucket_definition_for_job(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3BucketDefinitionForJob,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_266) = &input.account_id {
object.key("accountId").string(var_266.as_str());
}
if let Some(var_267) = &input.buckets {
let mut array_268 = object.key("buckets").start_array();
for item_269 in var_267 {
{
array_268.value().string(item_269.as_str());
}
}
array_268.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_scoping(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Scoping,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_270) = &input.excludes {
#[allow(unused_mut)]
let mut object_271 = object.key("excludes").start_object();
crate::json_ser::serialize_structure_crate_model_job_scoping_block(
&mut object_271,
var_270,
)?;
object_271.finish();
}
if let Some(var_272) = &input.includes {
#[allow(unused_mut)]
let mut object_273 = object.key("includes").start_object();
crate::json_ser::serialize_structure_crate_model_job_scoping_block(
&mut object_273,
var_272,
)?;
object_273.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_daily_schedule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DailySchedule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
Ok(())
}
pub fn serialize_structure_crate_model_monthly_schedule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonthlySchedule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.day_of_month != 0 {
object.key("dayOfMonth").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.day_of_month).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_weekly_schedule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WeeklySchedule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_274) = &input.day_of_week {
object.key("dayOfWeek").string(var_274.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_criterion_additional_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CriterionAdditionalProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_275) = &input.eq {
let mut array_276 = object.key("eq").start_array();
for item_277 in var_275 {
{
array_276.value().string(item_277.as_str());
}
}
array_276.finish();
}
if let Some(var_278) = &input.eq_exact_match {
let mut array_279 = object.key("eqExactMatch").start_array();
for item_280 in var_278 {
{
array_279.value().string(item_280.as_str());
}
}
array_279.finish();
}
if input.gt != 0 {
object.key("gt").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.gt).into()),
);
}
if input.gte != 0 {
object.key("gte").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.gte).into()),
);
}
if input.lt != 0 {
object.key("lt").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.lt).into()),
);
}
if input.lte != 0 {
object.key("lte").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.lte).into()),
);
}
if let Some(var_281) = &input.neq {
let mut array_282 = object.key("neq").start_array();
for item_283 in var_281 {
{
array_282.value().string(item_283.as_str());
}
}
array_282.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_list_jobs_filter_term(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListJobsFilterTerm,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_284) = &input.comparator {
object.key("comparator").string(var_284.as_str());
}
if let Some(var_285) = &input.key {
object.key("key").string(var_285.as_str());
}
if let Some(var_286) = &input.values {
let mut array_287 = object.key("values").start_array();
for item_288 in var_286 {
{
array_287.value().string(item_288.as_str());
}
}
array_287.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_destination(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3Destination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_289) = &input.bucket_name {
object.key("bucketName").string(var_289.as_str());
}
if let Some(var_290) = &input.key_prefix {
object.key("keyPrefix").string(var_290.as_str());
}
if let Some(var_291) = &input.kms_key_arn {
object.key("kmsKeyArn").string(var_291.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_search_resources_criteria_block(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SearchResourcesCriteriaBlock,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_292) = &input.and {
let mut array_293 = object.key("and").start_array();
for item_294 in var_292 {
{
#[allow(unused_mut)]
let mut object_295 = array_293.value().start_object();
crate::json_ser::serialize_structure_crate_model_search_resources_criteria(
&mut object_295,
item_294,
)?;
object_295.finish();
}
}
array_293.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_classification_scope_exclusion_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3ClassificationScopeExclusionUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_296) = &input.bucket_names {
let mut array_297 = object.key("bucketNames").start_array();
for item_298 in var_296 {
{
array_297.value().string(item_298.as_str());
}
}
array_297.finish();
}
if let Some(var_299) = &input.operation {
object.key("operation").string(var_299.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_criteria_block_for_job(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CriteriaBlockForJob,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_300) = &input.and {
let mut array_301 = object.key("and").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_criteria_for_job(
&mut object_303,
item_302,
)?;
object_303.finish();
}
}
array_301.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_job_scoping_block(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JobScopingBlock,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_304) = &input.and {
let mut array_305 = object.key("and").start_array();
for item_306 in var_304 {
{
#[allow(unused_mut)]
let mut object_307 = array_305.value().start_object();
crate::json_ser::serialize_structure_crate_model_job_scope_term(
&mut object_307,
item_306,
)?;
object_307.finish();
}
}
array_305.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_search_resources_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SearchResourcesCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_308) = &input.simple_criterion {
#[allow(unused_mut)]
let mut object_309 = object.key("simpleCriterion").start_object();
crate::json_ser::serialize_structure_crate_model_search_resources_simple_criterion(
&mut object_309,
var_308,
)?;
object_309.finish();
}
if let Some(var_310) = &input.tag_criterion {
#[allow(unused_mut)]
let mut object_311 = object.key("tagCriterion").start_object();
crate::json_ser::serialize_structure_crate_model_search_resources_tag_criterion(
&mut object_311,
var_310,
)?;
object_311.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_criteria_for_job(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CriteriaForJob,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_312) = &input.simple_criterion {
#[allow(unused_mut)]
let mut object_313 = object.key("simpleCriterion").start_object();
crate::json_ser::serialize_structure_crate_model_simple_criterion_for_job(
&mut object_313,
var_312,
)?;
object_313.finish();
}
if let Some(var_314) = &input.tag_criterion {
#[allow(unused_mut)]
let mut object_315 = object.key("tagCriterion").start_object();
crate::json_ser::serialize_structure_crate_model_tag_criterion_for_job(
&mut object_315,
var_314,
)?;
object_315.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_job_scope_term(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JobScopeTerm,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_316) = &input.simple_scope_term {
#[allow(unused_mut)]
let mut object_317 = object.key("simpleScopeTerm").start_object();
crate::json_ser::serialize_structure_crate_model_simple_scope_term(
&mut object_317,
var_316,
)?;
object_317.finish();
}
if let Some(var_318) = &input.tag_scope_term {
#[allow(unused_mut)]
let mut object_319 = object.key("tagScopeTerm").start_object();
crate::json_ser::serialize_structure_crate_model_tag_scope_term(&mut object_319, var_318)?;
object_319.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_search_resources_simple_criterion(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SearchResourcesSimpleCriterion,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_320) = &input.comparator {
object.key("comparator").string(var_320.as_str());
}
if let Some(var_321) = &input.key {
object.key("key").string(var_321.as_str());
}
if let Some(var_322) = &input.values {
let mut array_323 = object.key("values").start_array();
for item_324 in var_322 {
{
array_323.value().string(item_324.as_str());
}
}
array_323.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_search_resources_tag_criterion(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SearchResourcesTagCriterion,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_325) = &input.comparator {
object.key("comparator").string(var_325.as_str());
}
if let Some(var_326) = &input.tag_values {
let mut array_327 = object.key("tagValues").start_array();
for item_328 in var_326 {
{
#[allow(unused_mut)]
let mut object_329 = array_327.value().start_object();
crate::json_ser::serialize_structure_crate_model_search_resources_tag_criterion_pair(&mut object_329, item_328)?;
object_329.finish();
}
}
array_327.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_simple_criterion_for_job(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SimpleCriterionForJob,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_330) = &input.comparator {
object.key("comparator").string(var_330.as_str());
}
if let Some(var_331) = &input.key {
object.key("key").string(var_331.as_str());
}
if let Some(var_332) = &input.values {
let mut array_333 = object.key("values").start_array();
for item_334 in var_332 {
{
array_333.value().string(item_334.as_str());
}
}
array_333.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tag_criterion_for_job(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TagCriterionForJob,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_335) = &input.comparator {
object.key("comparator").string(var_335.as_str());
}
if let Some(var_336) = &input.tag_values {
let mut array_337 = object.key("tagValues").start_array();
for item_338 in var_336 {
{
#[allow(unused_mut)]
let mut object_339 = array_337.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_criterion_pair_for_job(
&mut object_339,
item_338,
)?;
object_339.finish();
}
}
array_337.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_simple_scope_term(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SimpleScopeTerm,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_340) = &input.comparator {
object.key("comparator").string(var_340.as_str());
}
if let Some(var_341) = &input.key {
object.key("key").string(var_341.as_str());
}
if let Some(var_342) = &input.values {
let mut array_343 = object.key("values").start_array();
for item_344 in var_342 {
{
array_343.value().string(item_344.as_str());
}
}
array_343.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tag_scope_term(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TagScopeTerm,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_345) = &input.comparator {
object.key("comparator").string(var_345.as_str());
}
if let Some(var_346) = &input.key {
object.key("key").string(var_346.as_str());
}
if let Some(var_347) = &input.tag_values {
let mut array_348 = object.key("tagValues").start_array();
for item_349 in var_347 {
{
#[allow(unused_mut)]
let mut object_350 = array_348.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_value_pair(
&mut object_350,
item_349,
)?;
object_350.finish();
}
}
array_348.finish();
}
if let Some(var_351) = &input.target {
object.key("target").string(var_351.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_search_resources_tag_criterion_pair(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SearchResourcesTagCriterionPair,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_352) = &input.key {
object.key("key").string(var_352.as_str());
}
if let Some(var_353) = &input.value {
object.key("value").string(var_353.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tag_criterion_pair_for_job(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TagCriterionPairForJob,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_354) = &input.key {
object.key("key").string(var_354.as_str());
}
if let Some(var_355) = &input.value {
object.key("value").string(var_355.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tag_value_pair(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TagValuePair,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_356) = &input.key {
object.key("key").string(var_356.as_str());
}
if let Some(var_357) = &input.value {
object.key("value").string(var_357.as_str());
}
Ok(())
}