pub fn serialize_structure_crate_input_accept_administrator_invitation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AcceptAdministratorInvitationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.administrator_id {
object.key("administratorId").string(var_1.as_str());
}
if let Some(var_2) = &input.invitation_id {
object.key("invitationId").string(var_2.as_str());
}
Ok(())
}
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_3) = &input.invitation_id {
object.key("invitationId").string(var_3.as_str());
}
if let Some(var_4) = &input.master_id {
object.key("masterId").string(var_4.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_archive_findings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ArchiveFindingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_5) = &input.finding_ids {
let mut array_6 = object.key("findingIds").start_array();
for item_7 in var_5 {
{
array_6.value().string(item_7.as_str());
}
}
array_6.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_detector_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDetectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_8) = &input.client_token {
object.key("clientToken").string(var_8.as_str());
}
if let Some(var_9) = &input.data_sources {
#[allow(unused_mut)]
let mut object_10 = object.key("dataSources").start_object();
crate::json_ser::serialize_structure_crate_model_data_source_configurations(
&mut object_10,
var_9,
)?;
object_10.finish();
}
{
object.key("enable").boolean(input.enable);
}
if let Some(var_11) = &input.finding_publishing_frequency {
object
.key("findingPublishingFrequency")
.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_filter_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFilterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_16) = &input.action {
object.key("action").string(var_16.as_str());
}
if let Some(var_17) = &input.client_token {
object.key("clientToken").string(var_17.as_str());
}
if let Some(var_18) = &input.description {
object.key("description").string(var_18.as_str());
}
if let Some(var_19) = &input.finding_criteria {
#[allow(unused_mut)]
let mut object_20 = object.key("findingCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_finding_criteria(&mut object_20, var_19)?;
object_20.finish();
}
if let Some(var_21) = &input.name {
object.key("name").string(var_21.as_str());
}
if input.rank != 0 {
object.key("rank").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.rank).into()),
);
}
if let Some(var_22) = &input.tags {
#[allow(unused_mut)]
let mut object_23 = object.key("tags").start_object();
for (key_24, value_25) in var_22 {
{
object_23.key(key_24.as_str()).string(value_25.as_str());
}
}
object_23.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_ip_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateIpSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("activate").boolean(input.activate);
}
if let Some(var_26) = &input.client_token {
object.key("clientToken").string(var_26.as_str());
}
if let Some(var_27) = &input.format {
object.key("format").string(var_27.as_str());
}
if let Some(var_28) = &input.location {
object.key("location").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.tags {
#[allow(unused_mut)]
let mut object_31 = object.key("tags").start_object();
for (key_32, value_33) in var_30 {
{
object_31.key(key_32.as_str()).string(value_33.as_str());
}
}
object_31.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_members_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateMembersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_34) = &input.account_details {
let mut array_35 = object.key("accountDetails").start_array();
for item_36 in var_34 {
{
#[allow(unused_mut)]
let mut object_37 = array_35.value().start_object();
crate::json_ser::serialize_structure_crate_model_account_detail(
&mut object_37,
item_36,
)?;
object_37.finish();
}
}
array_35.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_publishing_destination_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreatePublishingDestinationInput,
) -> 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.destination_properties {
#[allow(unused_mut)]
let mut object_40 = object.key("destinationProperties").start_object();
crate::json_ser::serialize_structure_crate_model_destination_properties(
&mut object_40,
var_39,
)?;
object_40.finish();
}
if let Some(var_41) = &input.destination_type {
object.key("destinationType").string(var_41.as_str());
}
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_42) = &input.finding_types {
let mut array_43 = object.key("findingTypes").start_array();
for item_44 in var_42 {
{
array_43.value().string(item_44.as_str());
}
}
array_43.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_threat_intel_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateThreatIntelSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("activate").boolean(input.activate);
}
if let Some(var_45) = &input.client_token {
object.key("clientToken").string(var_45.as_str());
}
if let Some(var_46) = &input.format {
object.key("format").string(var_46.as_str());
}
if let Some(var_47) = &input.location {
object.key("location").string(var_47.as_str());
}
if let Some(var_48) = &input.name {
object.key("name").string(var_48.as_str());
}
if let Some(var_49) = &input.tags {
#[allow(unused_mut)]
let mut object_50 = object.key("tags").start_object();
for (key_51, value_52) in var_49 {
{
object_50.key(key_51.as_str()).string(value_52.as_str());
}
}
object_50.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_53) = &input.account_ids {
let mut array_54 = object.key("accountIds").start_array();
for item_55 in var_53 {
{
array_54.value().string(item_55.as_str());
}
}
array_54.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_56) = &input.account_ids {
let mut array_57 = object.key("accountIds").start_array();
for item_58 in var_56 {
{
array_57.value().string(item_58.as_str());
}
}
array_57.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_members_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteMembersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_59) = &input.account_ids {
let mut array_60 = object.key("accountIds").start_array();
for item_61 in var_59 {
{
array_60.value().string(item_61.as_str());
}
}
array_60.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_malware_scans_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeMalwareScansInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_62) = &input.filter_criteria {
#[allow(unused_mut)]
let mut object_63 = object.key("filterCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_filter_criteria(&mut object_63, var_62)?;
object_63.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_64) = &input.next_token {
object.key("nextToken").string(var_64.as_str());
}
if let Some(var_65) = &input.sort_criteria {
#[allow(unused_mut)]
let mut object_66 = object.key("sortCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_sort_criteria(&mut object_66, var_65)?;
object_66.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_disable_organization_admin_account_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisableOrganizationAdminAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_67) = &input.admin_account_id {
object.key("adminAccountId").string(var_67.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_members_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateMembersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_68) = &input.account_ids {
let mut array_69 = object.key("accountIds").start_array();
for item_70 in var_68 {
{
array_69.value().string(item_70.as_str());
}
}
array_69.finish();
}
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_71) = &input.admin_account_id {
object.key("adminAccountId").string(var_71.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_72) = &input.finding_ids {
let mut array_73 = object.key("findingIds").start_array();
for item_74 in var_72 {
{
array_73.value().string(item_74.as_str());
}
}
array_73.finish();
}
if let Some(var_75) = &input.sort_criteria {
#[allow(unused_mut)]
let mut object_76 = object.key("sortCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_sort_criteria(&mut object_76, var_75)?;
object_76.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_findings_statistics_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetFindingsStatisticsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_77) = &input.finding_criteria {
#[allow(unused_mut)]
let mut object_78 = object.key("findingCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_finding_criteria(&mut object_78, var_77)?;
object_78.finish();
}
if let Some(var_79) = &input.finding_statistic_types {
let mut array_80 = object.key("findingStatisticTypes").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_get_member_detectors_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetMemberDetectorsInput,
) -> 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_get_members_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetMembersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.account_ids {
let mut array_86 = object.key("accountIds").start_array();
for item_87 in var_85 {
{
array_86.value().string(item_87.as_str());
}
}
array_86.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_remaining_free_trial_days_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetRemainingFreeTrialDaysInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_88) = &input.account_ids {
let mut array_89 = object.key("accountIds").start_array();
for item_90 in var_88 {
{
array_89.value().string(item_90.as_str());
}
}
array_89.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 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_91) = &input.next_token {
object.key("nextToken").string(var_91.as_str());
}
if let Some(var_92) = &input.unit {
object.key("unit").string(var_92.as_str());
}
if let Some(var_93) = &input.usage_criteria {
#[allow(unused_mut)]
let mut object_94 = object.key("usageCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_usage_criteria(&mut object_94, var_93)?;
object_94.finish();
}
if let Some(var_95) = &input.usage_statistic_type {
object.key("usageStatisticsType").string(var_95.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_invite_members_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::InviteMembersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_96) = &input.account_ids {
let mut array_97 = object.key("accountIds").start_array();
for item_98 in var_96 {
{
array_97.value().string(item_98.as_str());
}
}
array_97.finish();
}
if input.disable_email_notification {
object
.key("disableEmailNotification")
.boolean(input.disable_email_notification);
}
if let Some(var_99) = &input.message {
object.key("message").string(var_99.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_100) = &input.finding_criteria {
#[allow(unused_mut)]
let mut object_101 = object.key("findingCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_finding_criteria(
&mut object_101,
var_100,
)?;
object_101.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_102) = &input.next_token {
object.key("nextToken").string(var_102.as_str());
}
if let Some(var_103) = &input.sort_criteria {
#[allow(unused_mut)]
let mut object_104 = object.key("sortCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_sort_criteria(&mut object_104, var_103)?;
object_104.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_monitoring_members_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartMonitoringMembersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_105) = &input.account_ids {
let mut array_106 = object.key("accountIds").start_array();
for item_107 in var_105 {
{
array_106.value().string(item_107.as_str());
}
}
array_106.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_monitoring_members_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopMonitoringMembersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_108) = &input.account_ids {
let mut array_109 = object.key("accountIds").start_array();
for item_110 in var_108 {
{
array_109.value().string(item_110.as_str());
}
}
array_109.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_111) = &input.tags {
#[allow(unused_mut)]
let mut object_112 = object.key("tags").start_object();
for (key_113, value_114) in var_111 {
{
object_112.key(key_113.as_str()).string(value_114.as_str());
}
}
object_112.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_unarchive_findings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UnarchiveFindingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_115) = &input.finding_ids {
let mut array_116 = object.key("findingIds").start_array();
for item_117 in var_115 {
{
array_116.value().string(item_117.as_str());
}
}
array_116.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_detector_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDetectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_118) = &input.data_sources {
#[allow(unused_mut)]
let mut object_119 = object.key("dataSources").start_object();
crate::json_ser::serialize_structure_crate_model_data_source_configurations(
&mut object_119,
var_118,
)?;
object_119.finish();
}
if input.enable {
object.key("enable").boolean(input.enable);
}
if let Some(var_120) = &input.finding_publishing_frequency {
object
.key("findingPublishingFrequency")
.string(var_120.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_filter_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFilterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_121) = &input.action {
object.key("action").string(var_121.as_str());
}
if let Some(var_122) = &input.description {
object.key("description").string(var_122.as_str());
}
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.rank != 0 {
object.key("rank").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.rank).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_findings_feedback_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFindingsFeedbackInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_125) = &input.comments {
object.key("comments").string(var_125.as_str());
}
if let Some(var_126) = &input.feedback {
object.key("feedback").string(var_126.as_str());
}
if let Some(var_127) = &input.finding_ids {
let mut array_128 = object.key("findingIds").start_array();
for item_129 in var_127 {
{
array_128.value().string(item_129.as_str());
}
}
array_128.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_ip_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateIpSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.activate {
object.key("activate").boolean(input.activate);
}
if let Some(var_130) = &input.location {
object.key("location").string(var_130.as_str());
}
if let Some(var_131) = &input.name {
object.key("name").string(var_131.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_malware_scan_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateMalwareScanSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_132) = &input.ebs_snapshot_preservation {
object
.key("ebsSnapshotPreservation")
.string(var_132.as_str());
}
if let Some(var_133) = &input.scan_resource_criteria {
#[allow(unused_mut)]
let mut object_134 = object.key("scanResourceCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_scan_resource_criteria(
&mut object_134,
var_133,
)?;
object_134.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_member_detectors_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateMemberDetectorsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_135) = &input.account_ids {
let mut array_136 = object.key("accountIds").start_array();
for item_137 in var_135 {
{
array_136.value().string(item_137.as_str());
}
}
array_136.finish();
}
if let Some(var_138) = &input.data_sources {
#[allow(unused_mut)]
let mut object_139 = object.key("dataSources").start_object();
crate::json_ser::serialize_structure_crate_model_data_source_configurations(
&mut object_139,
var_138,
)?;
object_139.finish();
}
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);
}
if let Some(var_140) = &input.data_sources {
#[allow(unused_mut)]
let mut object_141 = object.key("dataSources").start_object();
crate::json_ser::serialize_structure_crate_model_organization_data_source_configurations(
&mut object_141,
var_140,
)?;
object_141.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_publishing_destination_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdatePublishingDestinationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_142) = &input.destination_properties {
#[allow(unused_mut)]
let mut object_143 = object.key("destinationProperties").start_object();
crate::json_ser::serialize_structure_crate_model_destination_properties(
&mut object_143,
var_142,
)?;
object_143.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_threat_intel_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateThreatIntelSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.activate {
object.key("activate").boolean(input.activate);
}
if let Some(var_144) = &input.location {
object.key("location").string(var_144.as_str());
}
if let Some(var_145) = &input.name {
object.key("name").string(var_145.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_data_source_configurations(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataSourceConfigurations,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.s3_logs {
#[allow(unused_mut)]
let mut object_147 = object.key("s3Logs").start_object();
crate::json_ser::serialize_structure_crate_model_s3_logs_configuration(
&mut object_147,
var_146,
)?;
object_147.finish();
}
if let Some(var_148) = &input.kubernetes {
#[allow(unused_mut)]
let mut object_149 = object.key("kubernetes").start_object();
crate::json_ser::serialize_structure_crate_model_kubernetes_configuration(
&mut object_149,
var_148,
)?;
object_149.finish();
}
if let Some(var_150) = &input.malware_protection {
#[allow(unused_mut)]
let mut object_151 = object.key("malwareProtection").start_object();
crate::json_ser::serialize_structure_crate_model_malware_protection_configuration(
&mut object_151,
var_150,
)?;
object_151.finish();
}
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_152) = &input.criterion {
#[allow(unused_mut)]
let mut object_153 = object.key("criterion").start_object();
for (key_154, value_155) in var_152 {
{
#[allow(unused_mut)]
let mut object_156 = object_153.key(key_154.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_condition(
&mut object_156,
value_155,
)?;
object_156.finish();
}
}
object_153.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_157) = &input.account_id {
object.key("accountId").string(var_157.as_str());
}
if let Some(var_158) = &input.email {
object.key("email").string(var_158.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_destination_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DestinationProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_159) = &input.destination_arn {
object.key("destinationArn").string(var_159.as_str());
}
if let Some(var_160) = &input.kms_key_arn {
object.key("kmsKeyArn").string(var_160.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_161) = &input.filter_criterion {
let mut array_162 = object.key("filterCriterion").start_array();
for item_163 in var_161 {
{
#[allow(unused_mut)]
let mut object_164 = array_162.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_criterion(
&mut object_164,
item_163,
)?;
object_164.finish();
}
}
array_162.finish();
}
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_165) = &input.attribute_name {
object.key("attributeName").string(var_165.as_str());
}
if let Some(var_166) = &input.order_by {
object.key("orderBy").string(var_166.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_usage_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UsageCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_167) = &input.account_ids {
let mut array_168 = object.key("accountIds").start_array();
for item_169 in var_167 {
{
array_168.value().string(item_169.as_str());
}
}
array_168.finish();
}
if let Some(var_170) = &input.data_sources {
let mut array_171 = object.key("dataSources").start_array();
for item_172 in var_170 {
{
array_171.value().string(item_172.as_str());
}
}
array_171.finish();
}
if let Some(var_173) = &input.resources {
let mut array_174 = object.key("resources").start_array();
for item_175 in var_173 {
{
array_174.value().string(item_175.as_str());
}
}
array_174.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_scan_resource_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScanResourceCriteria,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_176) = &input.include {
#[allow(unused_mut)]
let mut object_177 = object.key("include").start_object();
for (key_178, value_179) in var_176 {
{
#[allow(unused_mut)]
let mut object_180 = object_177.key(key_178.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_scan_condition(
&mut object_180,
value_179,
)?;
object_180.finish();
}
}
object_177.finish();
}
if let Some(var_181) = &input.exclude {
#[allow(unused_mut)]
let mut object_182 = object.key("exclude").start_object();
for (key_183, value_184) in var_181 {
{
#[allow(unused_mut)]
let mut object_185 = object_182.key(key_183.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_scan_condition(
&mut object_185,
value_184,
)?;
object_185.finish();
}
}
object_182.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_organization_data_source_configurations(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OrganizationDataSourceConfigurations,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_186) = &input.s3_logs {
#[allow(unused_mut)]
let mut object_187 = object.key("s3Logs").start_object();
crate::json_ser::serialize_structure_crate_model_organization_s3_logs_configuration(
&mut object_187,
var_186,
)?;
object_187.finish();
}
if let Some(var_188) = &input.kubernetes {
#[allow(unused_mut)]
let mut object_189 = object.key("kubernetes").start_object();
crate::json_ser::serialize_structure_crate_model_organization_kubernetes_configuration(
&mut object_189,
var_188,
)?;
object_189.finish();
}
if let Some(var_190) = &input.malware_protection {
#[allow(unused_mut)]
let mut object_191 = object.key("malwareProtection").start_object();
crate::json_ser::serialize_structure_crate_model_organization_malware_protection_configuration(&mut object_191, var_190)?;
object_191.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_logs_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3LogsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("enable").boolean(input.enable);
}
Ok(())
}
pub fn serialize_structure_crate_model_kubernetes_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KubernetesConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_192) = &input.audit_logs {
#[allow(unused_mut)]
let mut object_193 = object.key("auditLogs").start_object();
crate::json_ser::serialize_structure_crate_model_kubernetes_audit_logs_configuration(
&mut object_193,
var_192,
)?;
object_193.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_malware_protection_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MalwareProtectionConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_194) = &input.scan_ec2_instance_with_findings {
#[allow(unused_mut)]
let mut object_195 = object.key("scanEc2InstanceWithFindings").start_object();
crate::json_ser::serialize_structure_crate_model_scan_ec2_instance_with_findings(
&mut object_195,
var_194,
)?;
object_195.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Condition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_196) = &input.eq {
let mut array_197 = object.key("eq").start_array();
for item_198 in var_196 {
{
array_197.value().string(item_198.as_str());
}
}
array_197.finish();
}
if let Some(var_199) = &input.neq {
let mut array_200 = object.key("neq").start_array();
for item_201 in var_199 {
{
array_200.value().string(item_201.as_str());
}
}
array_200.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_202) = &input.equals {
let mut array_203 = object.key("equals").start_array();
for item_204 in var_202 {
{
array_203.value().string(item_204.as_str());
}
}
array_203.finish();
}
if let Some(var_205) = &input.not_equals {
let mut array_206 = object.key("notEquals").start_array();
for item_207 in var_205 {
{
array_206.value().string(item_207.as_str());
}
}
array_206.finish();
}
if input.greater_than != 0 {
object.key("greaterThan").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.greater_than).into()),
);
}
if input.greater_than_or_equal != 0 {
object.key("greaterThanOrEqual").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.greater_than_or_equal).into()),
);
}
if input.less_than != 0 {
object.key("lessThan").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.less_than).into()),
);
}
if input.less_than_or_equal != 0 {
object.key("lessThanOrEqual").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.less_than_or_equal).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_criterion(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterCriterion,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_208) = &input.criterion_key {
object.key("criterionKey").string(var_208.as_str());
}
if let Some(var_209) = &input.filter_condition {
#[allow(unused_mut)]
let mut object_210 = object.key("filterCondition").start_object();
crate::json_ser::serialize_structure_crate_model_filter_condition(
&mut object_210,
var_209,
)?;
object_210.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_scan_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScanCondition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_211) = &input.map_equals {
let mut array_212 = object.key("mapEquals").start_array();
for item_213 in var_211 {
{
#[allow(unused_mut)]
let mut object_214 = array_212.value().start_object();
crate::json_ser::serialize_structure_crate_model_scan_condition_pair(
&mut object_214,
item_213,
)?;
object_214.finish();
}
}
array_212.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_organization_s3_logs_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OrganizationS3LogsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("autoEnable").boolean(input.auto_enable);
}
Ok(())
}
pub fn serialize_structure_crate_model_organization_kubernetes_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OrganizationKubernetesConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_215) = &input.audit_logs {
#[allow(unused_mut)]
let mut object_216 = object.key("auditLogs").start_object();
crate::json_ser::serialize_structure_crate_model_organization_kubernetes_audit_logs_configuration(&mut object_216, var_215)?;
object_216.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_organization_malware_protection_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OrganizationMalwareProtectionConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_217) = &input.scan_ec2_instance_with_findings {
#[allow(unused_mut)]
let mut object_218 = object.key("scanEc2InstanceWithFindings").start_object();
crate::json_ser::serialize_structure_crate_model_organization_scan_ec2_instance_with_findings(&mut object_218, var_217)?;
object_218.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_kubernetes_audit_logs_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KubernetesAuditLogsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("enable").boolean(input.enable);
}
Ok(())
}
pub fn serialize_structure_crate_model_scan_ec2_instance_with_findings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScanEc2InstanceWithFindings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.ebs_volumes {
object.key("ebsVolumes").boolean(input.ebs_volumes);
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_condition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterCondition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_219) = &input.equals_value {
object.key("equalsValue").string(var_219.as_str());
}
if input.greater_than != 0 {
object.key("greaterThan").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.greater_than).into()),
);
}
if input.less_than != 0 {
object.key("lessThan").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.less_than).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_scan_condition_pair(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScanConditionPair,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_220) = &input.key {
object.key("key").string(var_220.as_str());
}
if let Some(var_221) = &input.value {
object.key("value").string(var_221.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_organization_kubernetes_audit_logs_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OrganizationKubernetesAuditLogsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("autoEnable").boolean(input.auto_enable);
}
Ok(())
}
pub fn serialize_structure_crate_model_organization_scan_ec2_instance_with_findings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OrganizationScanEc2InstanceWithFindings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_222) = &input.ebs_volumes {
#[allow(unused_mut)]
let mut object_223 = object.key("ebsVolumes").start_object();
crate::json_ser::serialize_structure_crate_model_organization_ebs_volumes(
&mut object_223,
var_222,
)?;
object_223.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_organization_ebs_volumes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OrganizationEbsVolumes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.auto_enable {
object.key("autoEnable").boolean(input.auto_enable);
}
Ok(())
}