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::SerializationError> {
if let Some(var_1) = &input.administrator_account_id {
object.key("administratorAccountId").string(var_1);
}
if let Some(var_2) = &input.invitation_id {
object.key("invitationId").string(var_2);
}
if let Some(var_3) = &input.master_account {
object.key("masterAccount").string(var_3);
}
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::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);
}
}
array_5.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::SerializationError> {
if let Some(var_7) = &input.client_token {
object.key("clientToken").string(var_7);
}
if let Some(var_8) = &input.custom_data_identifier_ids {
let mut array_9 = object.key("customDataIdentifierIds").start_array();
for item_10 in var_8 {
{
array_9.value().string(item_10);
}
}
array_9.finish();
}
if let Some(var_11) = &input.description {
object.key("description").string(var_11);
}
if input.initial_run {
object.key("initialRun").boolean(input.initial_run);
}
if let Some(var_12) = &input.job_type {
object.key("jobType").string(var_12.as_str());
}
if let Some(var_13) = &input.managed_data_identifier_ids {
let mut array_14 = object.key("managedDataIdentifierIds").start_array();
for item_15 in var_13 {
{
array_14.value().string(item_15);
}
}
array_14.finish();
}
if let Some(var_16) = &input.managed_data_identifier_selector {
object
.key("managedDataIdentifierSelector")
.string(var_16.as_str());
}
if let Some(var_17) = &input.name {
object.key("name").string(var_17);
}
if let Some(var_18) = &input.s3_job_definition {
let mut object_19 = object.key("s3JobDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_s3_job_definition(&mut object_19, var_18)?;
object_19.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_20) = &input.schedule_frequency {
let mut object_21 = object.key("scheduleFrequency").start_object();
crate::json_ser::serialize_structure_crate_model_job_schedule_frequency(
&mut object_21,
var_20,
)?;
object_21.finish();
}
if let Some(var_22) = &input.tags {
let mut object_23 = object.key("tags").start_object();
for (key_24, value_25) in var_22 {
{
object_23.key(key_24).string(value_25);
}
}
object_23.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::SerializationError> {
if let Some(var_26) = &input.client_token {
object.key("clientToken").string(var_26);
}
if let Some(var_27) = &input.description {
object.key("description").string(var_27);
}
if let Some(var_28) = &input.ignore_words {
let mut array_29 = object.key("ignoreWords").start_array();
for item_30 in var_28 {
{
array_29.value().string(item_30);
}
}
array_29.finish();
}
if let Some(var_31) = &input.keywords {
let mut array_32 = object.key("keywords").start_array();
for item_33 in var_31 {
{
array_32.value().string(item_33);
}
}
array_32.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_34) = &input.name {
object.key("name").string(var_34);
}
if let Some(var_35) = &input.regex {
object.key("regex").string(var_35);
}
if let Some(var_36) = &input.severity_levels {
let mut array_37 = object.key("severityLevels").start_array();
for item_38 in var_36 {
{
let mut object_39 = array_37.value().start_object();
crate::json_ser::serialize_structure_crate_model_severity_level(
&mut object_39,
item_38,
)?;
object_39.finish();
}
}
array_37.finish();
}
if let Some(var_40) = &input.tags {
let mut object_41 = object.key("tags").start_object();
for (key_42, value_43) in var_40 {
{
object_41.key(key_42).string(value_43);
}
}
object_41.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::SerializationError> {
if let Some(var_44) = &input.action {
object.key("action").string(var_44.as_str());
}
if let Some(var_45) = &input.client_token {
object.key("clientToken").string(var_45);
}
if let Some(var_46) = &input.description {
object.key("description").string(var_46);
}
if let Some(var_47) = &input.finding_criteria {
let mut object_48 = object.key("findingCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_finding_criteria(&mut object_48, var_47)?;
object_48.finish();
}
if let Some(var_49) = &input.name {
object.key("name").string(var_49);
}
if input.position != 0 {
object.key("position").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.position).into()),
);
}
if let Some(var_50) = &input.tags {
let mut object_51 = object.key("tags").start_object();
for (key_52, value_53) in var_50 {
{
object_51.key(key_52).string(value_53);
}
}
object_51.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::SerializationError> {
if let Some(var_54) = &input.account_ids {
let mut array_55 = object.key("accountIds").start_array();
for item_56 in var_54 {
{
array_55.value().string(item_56);
}
}
array_55.finish();
}
if input.disable_email_notification {
object
.key("disableEmailNotification")
.boolean(input.disable_email_notification);
}
if let Some(var_57) = &input.message {
object.key("message").string(var_57);
}
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::SerializationError> {
if let Some(var_58) = &input.account {
let mut object_59 = object.key("account").start_object();
crate::json_ser::serialize_structure_crate_model_account_detail(&mut object_59, var_58)?;
object_59.finish();
}
if let Some(var_60) = &input.tags {
let mut object_61 = object.key("tags").start_object();
for (key_62, value_63) in var_60 {
{
object_61.key(key_62).string(value_63);
}
}
object_61.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::SerializationError> {
if let Some(var_64) = &input.finding_types {
let mut array_65 = object.key("findingTypes").start_array();
for item_66 in var_64 {
{
array_65.value().string(item_66.as_str());
}
}
array_65.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::SerializationError> {
if let Some(var_67) = &input.account_ids {
let mut array_68 = object.key("accountIds").start_array();
for item_69 in var_67 {
{
array_68.value().string(item_69);
}
}
array_68.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::SerializationError> {
if let Some(var_70) = &input.account_ids {
let mut array_71 = object.key("accountIds").start_array();
for item_72 in var_70 {
{
array_71.value().string(item_72);
}
}
array_71.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::SerializationError> {
if let Some(var_73) = &input.criteria {
let mut object_74 = object.key("criteria").start_object();
for (key_75, value_76) in var_73 {
{
let mut object_77 = object_74.key(key_75).start_object();
crate::json_ser::serialize_structure_crate_model_bucket_criteria_additional_properties(&mut object_77, value_76)?;
object_77.finish();
}
}
object_74.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_78) = &input.next_token {
object.key("nextToken").string(var_78);
}
if let Some(var_79) = &input.sort_criteria {
let mut object_80 = object.key("sortCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_bucket_sort_criteria(
&mut object_80,
var_79,
)?;
object_80.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::SerializationError> {
if let Some(var_81) = &input.client_token {
object.key("clientToken").string(var_81);
}
if let Some(var_82) = &input.finding_publishing_frequency {
object
.key("findingPublishingFrequency")
.string(var_82.as_str());
}
if let Some(var_83) = &input.status {
object.key("status").string(var_83.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::SerializationError> {
if let Some(var_84) = &input.admin_account_id {
object.key("adminAccountId").string(var_84);
}
if let Some(var_85) = &input.client_token {
object.key("clientToken").string(var_85);
}
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::SerializationError> {
if let Some(var_86) = &input.account_id {
object.key("accountId").string(var_86);
}
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::SerializationError> {
if let Some(var_87) = &input.finding_ids {
let mut array_88 = object.key("findingIds").start_array();
for item_89 in var_87 {
{
array_88.value().string(item_89);
}
}
array_88.finish();
}
if let Some(var_90) = &input.sort_criteria {
let mut object_91 = object.key("sortCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_sort_criteria(&mut object_91, var_90)?;
object_91.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::SerializationError> {
if let Some(var_92) = &input.finding_criteria {
let mut object_93 = object.key("findingCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_finding_criteria(&mut object_93, var_92)?;
object_93.finish();
}
if let Some(var_94) = &input.group_by {
object.key("groupBy").string(var_94.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_95) = &input.sort_criteria {
let mut object_96 = object.key("sortCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_finding_statistics_sort_criteria(
&mut object_96,
var_95,
)?;
object_96.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::SerializationError> {
if let Some(var_97) = &input.filter_by {
let mut array_98 = object.key("filterBy").start_array();
for item_99 in var_97 {
{
let mut object_100 = array_98.value().start_object();
crate::json_ser::serialize_structure_crate_model_usage_statistics_filter(
&mut object_100,
item_99,
)?;
object_100.finish();
}
}
array_98.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_101) = &input.next_token {
object.key("nextToken").string(var_101);
}
if let Some(var_102) = &input.sort_by {
let mut object_103 = object.key("sortBy").start_object();
crate::json_ser::serialize_structure_crate_model_usage_statistics_sort_by(
&mut object_103,
var_102,
)?;
object_103.finish();
}
if let Some(var_104) = &input.time_range {
object.key("timeRange").string(var_104.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::SerializationError> {
if let Some(var_105) = &input.filter_criteria {
let mut object_106 = object.key("filterCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_list_jobs_filter_criteria(
&mut object_106,
var_105,
)?;
object_106.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_107) = &input.next_token {
object.key("nextToken").string(var_107);
}
if let Some(var_108) = &input.sort_criteria {
let mut object_109 = object.key("sortCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_list_jobs_sort_criteria(
&mut object_109,
var_108,
)?;
object_109.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::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_110) = &input.next_token {
object.key("nextToken").string(var_110);
}
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::SerializationError> {
if let Some(var_111) = &input.finding_criteria {
let mut object_112 = object.key("findingCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_finding_criteria(
&mut object_112,
var_111,
)?;
object_112.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);
}
if let Some(var_114) = &input.sort_criteria {
let mut object_115 = object.key("sortCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_sort_criteria(&mut object_115, var_114)?;
object_115.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::SerializationError> {
if let Some(var_116) = &input.next_token {
object.key("nextToken").string(var_116);
}
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::SerializationError> {
if let Some(var_117) = &input.configuration {
let mut object_118 = object.key("configuration").start_object();
crate::json_ser::serialize_structure_crate_model_classification_export_configuration(
&mut object_118,
var_117,
)?;
object_118.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::SerializationError> {
if let Some(var_119) = &input.client_token {
object.key("clientToken").string(var_119);
}
if let Some(var_120) = &input.security_hub_configuration {
let mut object_121 = object.key("securityHubConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_security_hub_configuration(
&mut object_121,
var_120,
)?;
object_121.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::SerializationError> {
if let Some(var_122) = &input.bucket_criteria {
let mut object_123 = object.key("bucketCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_search_resources_bucket_criteria(
&mut object_123,
var_122,
)?;
object_123.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_124) = &input.next_token {
object.key("nextToken").string(var_124);
}
if let Some(var_125) = &input.sort_criteria {
let mut object_126 = object.key("sortCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_search_resources_sort_criteria(
&mut object_126,
var_125,
)?;
object_126.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::SerializationError> {
if let Some(var_127) = &input.tags {
let mut object_128 = object.key("tags").start_object();
for (key_129, value_130) in var_127 {
{
object_128.key(key_129).string(value_130);
}
}
object_128.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::SerializationError> {
if let Some(var_131) = &input.ignore_words {
let mut array_132 = object.key("ignoreWords").start_array();
for item_133 in var_131 {
{
array_132.value().string(item_133);
}
}
array_132.finish();
}
if let Some(var_134) = &input.keywords {
let mut array_135 = object.key("keywords").start_array();
for item_136 in var_134 {
{
array_135.value().string(item_136);
}
}
array_135.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_137) = &input.regex {
object.key("regex").string(var_137);
}
if let Some(var_138) = &input.sample_text {
object.key("sampleText").string(var_138);
}
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::SerializationError> {
if let Some(var_139) = &input.job_status {
object.key("jobStatus").string(var_139.as_str());
}
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::SerializationError> {
if let Some(var_140) = &input.action {
object.key("action").string(var_140.as_str());
}
if let Some(var_141) = &input.client_token {
object.key("clientToken").string(var_141);
}
if let Some(var_142) = &input.description {
object.key("description").string(var_142);
}
if let Some(var_143) = &input.finding_criteria {
let mut object_144 = object.key("findingCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_finding_criteria(
&mut object_144,
var_143,
)?;
object_144.finish();
}
if let Some(var_145) = &input.name {
object.key("name").string(var_145);
}
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::SerializationError> {
if let Some(var_146) = &input.finding_publishing_frequency {
object
.key("findingPublishingFrequency")
.string(var_146.as_str());
}
if let Some(var_147) = &input.status {
object.key("status").string(var_147.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::SerializationError> {
if let Some(var_148) = &input.status {
object.key("status").string(var_148.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::SerializationError> {
{
object.key("autoEnable").boolean(input.auto_enable);
}
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::SerializationError> {
if let Some(var_149) = &input.bucket_definitions {
let mut array_150 = object.key("bucketDefinitions").start_array();
for item_151 in var_149 {
{
let mut object_152 = array_150.value().start_object();
crate::json_ser::serialize_structure_crate_model_s3_bucket_definition_for_job(
&mut object_152,
item_151,
)?;
object_152.finish();
}
}
array_150.finish();
}
if let Some(var_153) = &input.scoping {
let mut object_154 = object.key("scoping").start_object();
crate::json_ser::serialize_structure_crate_model_scoping(&mut object_154, var_153)?;
object_154.finish();
}
if let Some(var_155) = &input.bucket_criteria {
let mut object_156 = object.key("bucketCriteria").start_object();
crate::json_ser::serialize_structure_crate_model_s3_bucket_criteria_for_job(
&mut object_156,
var_155,
)?;
object_156.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::SerializationError> {
if let Some(var_157) = &input.daily_schedule {
let mut object_158 = object.key("dailySchedule").start_object();
crate::json_ser::serialize_structure_crate_model_daily_schedule(&mut object_158, var_157)?;
object_158.finish();
}
if let Some(var_159) = &input.monthly_schedule {
let mut object_160 = object.key("monthlySchedule").start_object();
crate::json_ser::serialize_structure_crate_model_monthly_schedule(
&mut object_160,
var_159,
)?;
object_160.finish();
}
if let Some(var_161) = &input.weekly_schedule {
let mut object_162 = object.key("weeklySchedule").start_object();
crate::json_ser::serialize_structure_crate_model_weekly_schedule(&mut object_162, var_161)?;
object_162.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::SerializationError> {
{
object.key("occurrencesThreshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.occurrences_threshold).into()),
);
}
if let Some(var_163) = &input.severity {
object.key("severity").string(var_163.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::SerializationError> {
if let Some(var_164) = &input.criterion {
let mut object_165 = object.key("criterion").start_object();
for (key_166, value_167) in var_164 {
{
let mut object_168 = object_165.key(key_166).start_object();
crate::json_ser::serialize_structure_crate_model_criterion_additional_properties(
&mut object_168,
value_167,
)?;
object_168.finish();
}
}
object_165.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::SerializationError> {
if let Some(var_169) = &input.account_id {
object.key("accountId").string(var_169);
}
if let Some(var_170) = &input.email {
object.key("email").string(var_170);
}
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::SerializationError> {
if let Some(var_171) = &input.eq {
let mut array_172 = object.key("eq").start_array();
for item_173 in var_171 {
{
array_172.value().string(item_173);
}
}
array_172.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_174) = &input.neq {
let mut array_175 = object.key("neq").start_array();
for item_176 in var_174 {
{
array_175.value().string(item_176);
}
}
array_175.finish();
}
if let Some(var_177) = &input.prefix {
object.key("prefix").string(var_177);
}
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::SerializationError> {
if let Some(var_178) = &input.attribute_name {
object.key("attributeName").string(var_178);
}
if let Some(var_179) = &input.order_by {
object.key("orderBy").string(var_179.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::SerializationError> {
if let Some(var_180) = &input.attribute_name {
object.key("attributeName").string(var_180);
}
if let Some(var_181) = &input.order_by {
object.key("orderBy").string(var_181.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::SerializationError> {
if let Some(var_182) = &input.attribute_name {
object.key("attributeName").string(var_182.as_str());
}
if let Some(var_183) = &input.order_by {
object.key("orderBy").string(var_183.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::SerializationError> {
if let Some(var_184) = &input.comparator {
object.key("comparator").string(var_184.as_str());
}
if let Some(var_185) = &input.key {
object.key("key").string(var_185.as_str());
}
if let Some(var_186) = &input.values {
let mut array_187 = object.key("values").start_array();
for item_188 in var_186 {
{
array_187.value().string(item_188);
}
}
array_187.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::SerializationError> {
if let Some(var_189) = &input.key {
object.key("key").string(var_189.as_str());
}
if let Some(var_190) = &input.order_by {
object.key("orderBy").string(var_190.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::SerializationError> {
if let Some(var_191) = &input.excludes {
let mut array_192 = object.key("excludes").start_array();
for item_193 in var_191 {
{
let mut object_194 = array_192.value().start_object();
crate::json_ser::serialize_structure_crate_model_list_jobs_filter_term(
&mut object_194,
item_193,
)?;
object_194.finish();
}
}
array_192.finish();
}
if let Some(var_195) = &input.includes {
let mut array_196 = object.key("includes").start_array();
for item_197 in var_195 {
{
let mut object_198 = array_196.value().start_object();
crate::json_ser::serialize_structure_crate_model_list_jobs_filter_term(
&mut object_198,
item_197,
)?;
object_198.finish();
}
}
array_196.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::SerializationError> {
if let Some(var_199) = &input.attribute_name {
object.key("attributeName").string(var_199.as_str());
}
if let Some(var_200) = &input.order_by {
object.key("orderBy").string(var_200.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::SerializationError> {
if let Some(var_201) = &input.s3_destination {
let mut object_202 = object.key("s3Destination").start_object();
crate::json_ser::serialize_structure_crate_model_s3_destination(&mut object_202, var_201)?;
object_202.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::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::SerializationError> {
if let Some(var_203) = &input.excludes {
let mut object_204 = object.key("excludes").start_object();
crate::json_ser::serialize_structure_crate_model_search_resources_criteria_block(
&mut object_204,
var_203,
)?;
object_204.finish();
}
if let Some(var_205) = &input.includes {
let mut object_206 = object.key("includes").start_object();
crate::json_ser::serialize_structure_crate_model_search_resources_criteria_block(
&mut object_206,
var_205,
)?;
object_206.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::SerializationError> {
if let Some(var_207) = &input.attribute_name {
object.key("attributeName").string(var_207.as_str());
}
if let Some(var_208) = &input.order_by {
object.key("orderBy").string(var_208.as_str());
}
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::SerializationError> {
if let Some(var_209) = &input.account_id {
object.key("accountId").string(var_209);
}
if let Some(var_210) = &input.buckets {
let mut array_211 = object.key("buckets").start_array();
for item_212 in var_210 {
{
array_211.value().string(item_212);
}
}
array_211.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::SerializationError> {
if let Some(var_213) = &input.excludes {
let mut object_214 = object.key("excludes").start_object();
crate::json_ser::serialize_structure_crate_model_job_scoping_block(
&mut object_214,
var_213,
)?;
object_214.finish();
}
if let Some(var_215) = &input.includes {
let mut object_216 = object.key("includes").start_object();
crate::json_ser::serialize_structure_crate_model_job_scoping_block(
&mut object_216,
var_215,
)?;
object_216.finish();
}
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::SerializationError> {
if let Some(var_217) = &input.excludes {
let mut object_218 = object.key("excludes").start_object();
crate::json_ser::serialize_structure_crate_model_criteria_block_for_job(
&mut object_218,
var_217,
)?;
object_218.finish();
}
if let Some(var_219) = &input.includes {
let mut object_220 = object.key("includes").start_object();
crate::json_ser::serialize_structure_crate_model_criteria_block_for_job(
&mut object_220,
var_219,
)?;
object_220.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::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::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::SerializationError> {
if let Some(var_221) = &input.day_of_week {
object.key("dayOfWeek").string(var_221.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::SerializationError> {
if let Some(var_222) = &input.eq {
let mut array_223 = object.key("eq").start_array();
for item_224 in var_222 {
{
array_223.value().string(item_224);
}
}
array_223.finish();
}
if let Some(var_225) = &input.eq_exact_match {
let mut array_226 = object.key("eqExactMatch").start_array();
for item_227 in var_225 {
{
array_226.value().string(item_227);
}
}
array_226.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_228) = &input.neq {
let mut array_229 = object.key("neq").start_array();
for item_230 in var_228 {
{
array_229.value().string(item_230);
}
}
array_229.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::SerializationError> {
if let Some(var_231) = &input.comparator {
object.key("comparator").string(var_231.as_str());
}
if let Some(var_232) = &input.key {
object.key("key").string(var_232.as_str());
}
if let Some(var_233) = &input.values {
let mut array_234 = object.key("values").start_array();
for item_235 in var_233 {
{
array_234.value().string(item_235);
}
}
array_234.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::SerializationError> {
if let Some(var_236) = &input.bucket_name {
object.key("bucketName").string(var_236);
}
if let Some(var_237) = &input.key_prefix {
object.key("keyPrefix").string(var_237);
}
if let Some(var_238) = &input.kms_key_arn {
object.key("kmsKeyArn").string(var_238);
}
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::SerializationError> {
if let Some(var_239) = &input.and {
let mut array_240 = object.key("and").start_array();
for item_241 in var_239 {
{
let mut object_242 = array_240.value().start_object();
crate::json_ser::serialize_structure_crate_model_search_resources_criteria(
&mut object_242,
item_241,
)?;
object_242.finish();
}
}
array_240.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::SerializationError> {
if let Some(var_243) = &input.and {
let mut array_244 = object.key("and").start_array();
for item_245 in var_243 {
{
let mut object_246 = array_244.value().start_object();
crate::json_ser::serialize_structure_crate_model_job_scope_term(
&mut object_246,
item_245,
)?;
object_246.finish();
}
}
array_244.finish();
}
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::SerializationError> {
if let Some(var_247) = &input.and {
let mut array_248 = object.key("and").start_array();
for item_249 in var_247 {
{
let mut object_250 = array_248.value().start_object();
crate::json_ser::serialize_structure_crate_model_criteria_for_job(
&mut object_250,
item_249,
)?;
object_250.finish();
}
}
array_248.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::SerializationError> {
if let Some(var_251) = &input.simple_criterion {
let mut object_252 = object.key("simpleCriterion").start_object();
crate::json_ser::serialize_structure_crate_model_search_resources_simple_criterion(
&mut object_252,
var_251,
)?;
object_252.finish();
}
if let Some(var_253) = &input.tag_criterion {
let mut object_254 = object.key("tagCriterion").start_object();
crate::json_ser::serialize_structure_crate_model_search_resources_tag_criterion(
&mut object_254,
var_253,
)?;
object_254.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::SerializationError> {
if let Some(var_255) = &input.simple_scope_term {
let mut object_256 = object.key("simpleScopeTerm").start_object();
crate::json_ser::serialize_structure_crate_model_simple_scope_term(
&mut object_256,
var_255,
)?;
object_256.finish();
}
if let Some(var_257) = &input.tag_scope_term {
let mut object_258 = object.key("tagScopeTerm").start_object();
crate::json_ser::serialize_structure_crate_model_tag_scope_term(&mut object_258, var_257)?;
object_258.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::SerializationError> {
if let Some(var_259) = &input.simple_criterion {
let mut object_260 = object.key("simpleCriterion").start_object();
crate::json_ser::serialize_structure_crate_model_simple_criterion_for_job(
&mut object_260,
var_259,
)?;
object_260.finish();
}
if let Some(var_261) = &input.tag_criterion {
let mut object_262 = object.key("tagCriterion").start_object();
crate::json_ser::serialize_structure_crate_model_tag_criterion_for_job(
&mut object_262,
var_261,
)?;
object_262.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::SerializationError> {
if let Some(var_263) = &input.comparator {
object.key("comparator").string(var_263.as_str());
}
if let Some(var_264) = &input.key {
object.key("key").string(var_264.as_str());
}
if let Some(var_265) = &input.values {
let mut array_266 = object.key("values").start_array();
for item_267 in var_265 {
{
array_266.value().string(item_267);
}
}
array_266.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::SerializationError> {
if let Some(var_268) = &input.comparator {
object.key("comparator").string(var_268.as_str());
}
if let Some(var_269) = &input.tag_values {
let mut array_270 = object.key("tagValues").start_array();
for item_271 in var_269 {
{
let mut object_272 = array_270.value().start_object();
crate::json_ser::serialize_structure_crate_model_search_resources_tag_criterion_pair(&mut object_272, item_271)?;
object_272.finish();
}
}
array_270.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::SerializationError> {
if let Some(var_273) = &input.comparator {
object.key("comparator").string(var_273.as_str());
}
if let Some(var_274) = &input.key {
object.key("key").string(var_274.as_str());
}
if let Some(var_275) = &input.values {
let mut array_276 = object.key("values").start_array();
for item_277 in var_275 {
{
array_276.value().string(item_277);
}
}
array_276.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::SerializationError> {
if let Some(var_278) = &input.comparator {
object.key("comparator").string(var_278.as_str());
}
if let Some(var_279) = &input.key {
object.key("key").string(var_279);
}
if let Some(var_280) = &input.tag_values {
let mut array_281 = object.key("tagValues").start_array();
for item_282 in var_280 {
{
let mut object_283 = array_281.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_value_pair(
&mut object_283,
item_282,
)?;
object_283.finish();
}
}
array_281.finish();
}
if let Some(var_284) = &input.target {
object.key("target").string(var_284.as_str());
}
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::SerializationError> {
if let Some(var_285) = &input.comparator {
object.key("comparator").string(var_285.as_str());
}
if let Some(var_286) = &input.key {
object.key("key").string(var_286.as_str());
}
if let Some(var_287) = &input.values {
let mut array_288 = object.key("values").start_array();
for item_289 in var_287 {
{
array_288.value().string(item_289);
}
}
array_288.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::SerializationError> {
if let Some(var_290) = &input.comparator {
object.key("comparator").string(var_290.as_str());
}
if let Some(var_291) = &input.tag_values {
let mut array_292 = object.key("tagValues").start_array();
for item_293 in var_291 {
{
let mut object_294 = array_292.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_criterion_pair_for_job(
&mut object_294,
item_293,
)?;
object_294.finish();
}
}
array_292.finish();
}
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::SerializationError> {
if let Some(var_295) = &input.key {
object.key("key").string(var_295);
}
if let Some(var_296) = &input.value {
object.key("value").string(var_296);
}
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::SerializationError> {
if let Some(var_297) = &input.key {
object.key("key").string(var_297);
}
if let Some(var_298) = &input.value {
object.key("value").string(var_298);
}
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::SerializationError> {
if let Some(var_299) = &input.key {
object.key("key").string(var_299);
}
if let Some(var_300) = &input.value {
object.key("value").string(var_300);
}
Ok(())
}