pub fn serialize_structure_crate_input_associate_assessment_report_evidence_folder_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateAssessmentReportEvidenceFolderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.evidence_folder_id {
object.key("evidenceFolderId").string(var_1.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_associate_assessment_report_evidence_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchAssociateAssessmentReportEvidenceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2) = &input.evidence_folder_id {
object.key("evidenceFolderId").string(var_2.as_str());
}
if let Some(var_3) = &input.evidence_ids {
let mut array_4 = object.key("evidenceIds").start_array();
for item_5 in var_3 {
{
array_4.value().string(item_5.as_str());
}
}
array_4.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_create_delegation_by_assessment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchCreateDelegationByAssessmentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_6) = &input.create_delegation_requests {
let mut array_7 = object.key("createDelegationRequests").start_array();
for item_8 in var_6 {
{
#[allow(unused_mut)]
let mut object_9 = array_7.value().start_object();
crate::json_ser::serialize_structure_crate_model_create_delegation_request(
&mut object_9,
item_8,
)?;
object_9.finish();
}
}
array_7.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_delete_delegation_by_assessment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDeleteDelegationByAssessmentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_10) = &input.delegation_ids {
let mut array_11 = object.key("delegationIds").start_array();
for item_12 in var_10 {
{
array_11.value().string(item_12.as_str());
}
}
array_11.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_disassociate_assessment_report_evidence_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDisassociateAssessmentReportEvidenceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_13) = &input.evidence_folder_id {
object.key("evidenceFolderId").string(var_13.as_str());
}
if let Some(var_14) = &input.evidence_ids {
let mut array_15 = object.key("evidenceIds").start_array();
for item_16 in var_14 {
{
array_15.value().string(item_16.as_str());
}
}
array_15.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_import_evidence_to_assessment_control_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchImportEvidenceToAssessmentControlInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_17) = &input.manual_evidence {
let mut array_18 = object.key("manualEvidence").start_array();
for item_19 in var_17 {
{
#[allow(unused_mut)]
let mut object_20 = array_18.value().start_object();
crate::json_ser::serialize_structure_crate_model_manual_evidence(
&mut object_20,
item_19,
)?;
object_20.finish();
}
}
array_18.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_assessment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAssessmentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_21) = &input.assessment_reports_destination {
#[allow(unused_mut)]
let mut object_22 = object.key("assessmentReportsDestination").start_object();
crate::json_ser::serialize_structure_crate_model_assessment_reports_destination(
&mut object_22,
var_21,
)?;
object_22.finish();
}
if let Some(var_23) = &input.description {
object.key("description").string(var_23.as_str());
}
if let Some(var_24) = &input.framework_id {
object.key("frameworkId").string(var_24.as_str());
}
if let Some(var_25) = &input.name {
object.key("name").string(var_25.as_str());
}
if let Some(var_26) = &input.roles {
let mut array_27 = object.key("roles").start_array();
for item_28 in var_26 {
{
#[allow(unused_mut)]
let mut object_29 = array_27.value().start_object();
crate::json_ser::serialize_structure_crate_model_role(&mut object_29, item_28)?;
object_29.finish();
}
}
array_27.finish();
}
if let Some(var_30) = &input.scope {
#[allow(unused_mut)]
let mut object_31 = object.key("scope").start_object();
crate::json_ser::serialize_structure_crate_model_scope(&mut object_31, var_30)?;
object_31.finish();
}
if let Some(var_32) = &input.tags {
#[allow(unused_mut)]
let mut object_33 = object.key("tags").start_object();
for (key_34, value_35) in var_32 {
{
object_33.key(key_34.as_str()).string(value_35.as_str());
}
}
object_33.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_assessment_framework_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAssessmentFrameworkInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_36) = &input.compliance_type {
object.key("complianceType").string(var_36.as_str());
}
if let Some(var_37) = &input.control_sets {
let mut array_38 = object.key("controlSets").start_array();
for item_39 in var_37 {
{
#[allow(unused_mut)]
let mut object_40 = array_38.value().start_object();
crate::json_ser::serialize_structure_crate_model_create_assessment_framework_control_set(&mut object_40, item_39)?;
object_40.finish();
}
}
array_38.finish();
}
if let Some(var_41) = &input.description {
object.key("description").string(var_41.as_str());
}
if let Some(var_42) = &input.name {
object.key("name").string(var_42.as_str());
}
if let Some(var_43) = &input.tags {
#[allow(unused_mut)]
let mut object_44 = object.key("tags").start_object();
for (key_45, value_46) in var_43 {
{
object_44.key(key_45.as_str()).string(value_46.as_str());
}
}
object_44.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_assessment_report_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAssessmentReportInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_47) = &input.description {
object.key("description").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.query_statement {
object.key("queryStatement").string(var_49.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_control_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateControlInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.action_plan_instructions {
object.key("actionPlanInstructions").string(var_50.as_str());
}
if let Some(var_51) = &input.action_plan_title {
object.key("actionPlanTitle").string(var_51.as_str());
}
if let Some(var_52) = &input.control_mapping_sources {
let mut array_53 = object.key("controlMappingSources").start_array();
for item_54 in var_52 {
{
#[allow(unused_mut)]
let mut object_55 = array_53.value().start_object();
crate::json_ser::serialize_structure_crate_model_create_control_mapping_source(
&mut object_55,
item_54,
)?;
object_55.finish();
}
}
array_53.finish();
}
if let Some(var_56) = &input.description {
object.key("description").string(var_56.as_str());
}
if let Some(var_57) = &input.name {
object.key("name").string(var_57.as_str());
}
if let Some(var_58) = &input.tags {
#[allow(unused_mut)]
let mut object_59 = object.key("tags").start_object();
for (key_60, value_61) in var_58 {
{
object_59.key(key_60.as_str()).string(value_61.as_str());
}
}
object_59.finish();
}
if let Some(var_62) = &input.testing_information {
object.key("testingInformation").string(var_62.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_deregister_organization_admin_account_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeregisterOrganizationAdminAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_63) = &input.admin_account_id {
object.key("adminAccountId").string(var_63.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_assessment_report_evidence_folder_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateAssessmentReportEvidenceFolderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_64) = &input.evidence_folder_id {
object.key("evidenceFolderId").string(var_64.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_register_account_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterAccountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_65) = &input.delegated_admin_account {
object.key("delegatedAdminAccount").string(var_65.as_str());
}
if let Some(var_66) = &input.kms_key {
object.key("kmsKey").string(var_66.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_register_organization_admin_account_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterOrganizationAdminAccountInput,
) -> 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_start_assessment_framework_share_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartAssessmentFrameworkShareInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_68) = &input.comment {
object.key("comment").string(var_68.as_str());
}
if let Some(var_69) = &input.destination_account {
object.key("destinationAccount").string(var_69.as_str());
}
if let Some(var_70) = &input.destination_region {
object.key("destinationRegion").string(var_70.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_71) = &input.tags {
#[allow(unused_mut)]
let mut object_72 = object.key("tags").start_object();
for (key_73, value_74) in var_71 {
{
object_72.key(key_73.as_str()).string(value_74.as_str());
}
}
object_72.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_assessment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAssessmentInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_75) = &input.assessment_description {
object.key("assessmentDescription").string(var_75.as_str());
}
if let Some(var_76) = &input.assessment_name {
object.key("assessmentName").string(var_76.as_str());
}
if let Some(var_77) = &input.assessment_reports_destination {
#[allow(unused_mut)]
let mut object_78 = object.key("assessmentReportsDestination").start_object();
crate::json_ser::serialize_structure_crate_model_assessment_reports_destination(
&mut object_78,
var_77,
)?;
object_78.finish();
}
if let Some(var_79) = &input.roles {
let mut array_80 = object.key("roles").start_array();
for item_81 in var_79 {
{
#[allow(unused_mut)]
let mut object_82 = array_80.value().start_object();
crate::json_ser::serialize_structure_crate_model_role(&mut object_82, item_81)?;
object_82.finish();
}
}
array_80.finish();
}
if let Some(var_83) = &input.scope {
#[allow(unused_mut)]
let mut object_84 = object.key("scope").start_object();
crate::json_ser::serialize_structure_crate_model_scope(&mut object_84, var_83)?;
object_84.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_assessment_control_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAssessmentControlInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.comment_body {
object.key("commentBody").string(var_85.as_str());
}
if let Some(var_86) = &input.control_status {
object.key("controlStatus").string(var_86.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_assessment_control_set_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAssessmentControlSetStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_87) = &input.comment {
object.key("comment").string(var_87.as_str());
}
if let Some(var_88) = &input.status {
object.key("status").string(var_88.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_assessment_framework_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAssessmentFrameworkInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.compliance_type {
object.key("complianceType").string(var_89.as_str());
}
if let Some(var_90) = &input.control_sets {
let mut array_91 = object.key("controlSets").start_array();
for item_92 in var_90 {
{
#[allow(unused_mut)]
let mut object_93 = array_91.value().start_object();
crate::json_ser::serialize_structure_crate_model_update_assessment_framework_control_set(&mut object_93, item_92)?;
object_93.finish();
}
}
array_91.finish();
}
if let Some(var_94) = &input.description {
object.key("description").string(var_94.as_str());
}
if let Some(var_95) = &input.name {
object.key("name").string(var_95.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_assessment_framework_share_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAssessmentFrameworkShareInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_96) = &input.action {
object.key("action").string(var_96.as_str());
}
if let Some(var_97) = &input.request_type {
object.key("requestType").string(var_97.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_assessment_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAssessmentStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_98) = &input.status {
object.key("status").string(var_98.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_control_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateControlInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_99) = &input.action_plan_instructions {
object.key("actionPlanInstructions").string(var_99.as_str());
}
if let Some(var_100) = &input.action_plan_title {
object.key("actionPlanTitle").string(var_100.as_str());
}
if let Some(var_101) = &input.control_mapping_sources {
let mut array_102 = object.key("controlMappingSources").start_array();
for item_103 in var_101 {
{
#[allow(unused_mut)]
let mut object_104 = array_102.value().start_object();
crate::json_ser::serialize_structure_crate_model_control_mapping_source(
&mut object_104,
item_103,
)?;
object_104.finish();
}
}
array_102.finish();
}
if let Some(var_105) = &input.description {
object.key("description").string(var_105.as_str());
}
if let Some(var_106) = &input.name {
object.key("name").string(var_106.as_str());
}
if let Some(var_107) = &input.testing_information {
object.key("testingInformation").string(var_107.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_108) = &input.default_assessment_reports_destination {
#[allow(unused_mut)]
let mut object_109 = object
.key("defaultAssessmentReportsDestination")
.start_object();
crate::json_ser::serialize_structure_crate_model_assessment_reports_destination(
&mut object_109,
var_108,
)?;
object_109.finish();
}
if let Some(var_110) = &input.default_process_owners {
let mut array_111 = object.key("defaultProcessOwners").start_array();
for item_112 in var_110 {
{
#[allow(unused_mut)]
let mut object_113 = array_111.value().start_object();
crate::json_ser::serialize_structure_crate_model_role(&mut object_113, item_112)?;
object_113.finish();
}
}
array_111.finish();
}
if let Some(var_114) = &input.deregistration_policy {
#[allow(unused_mut)]
let mut object_115 = object.key("deregistrationPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_deregistration_policy(
&mut object_115,
var_114,
)?;
object_115.finish();
}
if let Some(var_116) = &input.evidence_finder_enabled {
object.key("evidenceFinderEnabled").boolean(*var_116);
}
if let Some(var_117) = &input.kms_key {
object.key("kmsKey").string(var_117.as_str());
}
if let Some(var_118) = &input.sns_topic {
object.key("snsTopic").string(var_118.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_validate_assessment_report_integrity_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ValidateAssessmentReportIntegrityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_119) = &input.s3_relative_path {
object.key("s3RelativePath").string(var_119.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_create_delegation_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateDelegationRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_120) = &input.comment {
object.key("comment").string(var_120.as_str());
}
if let Some(var_121) = &input.control_set_id {
object.key("controlSetId").string(var_121.as_str());
}
if let Some(var_122) = &input.role_arn {
object.key("roleArn").string(var_122.as_str());
}
if let Some(var_123) = &input.role_type {
object.key("roleType").string(var_123.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_manual_evidence(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ManualEvidence,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_124) = &input.s3_resource_path {
object.key("s3ResourcePath").string(var_124.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_assessment_reports_destination(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AssessmentReportsDestination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_125) = &input.destination_type {
object.key("destinationType").string(var_125.as_str());
}
if let Some(var_126) = &input.destination {
object.key("destination").string(var_126.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_role(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Role,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_127) = &input.role_type {
object.key("roleType").string(var_127.as_str());
}
if let Some(var_128) = &input.role_arn {
object.key("roleArn").string(var_128.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_scope(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Scope,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_129) = &input.aws_accounts {
let mut array_130 = object.key("awsAccounts").start_array();
for item_131 in var_129 {
{
#[allow(unused_mut)]
let mut object_132 = array_130.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_account(
&mut object_132,
item_131,
)?;
object_132.finish();
}
}
array_130.finish();
}
if let Some(var_133) = &input.aws_services {
let mut array_134 = object.key("awsServices").start_array();
for item_135 in var_133 {
{
#[allow(unused_mut)]
let mut object_136 = array_134.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_service(
&mut object_136,
item_135,
)?;
object_136.finish();
}
}
array_134.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_create_assessment_framework_control_set(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateAssessmentFrameworkControlSet,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_137) = &input.name {
object.key("name").string(var_137.as_str());
}
if let Some(var_138) = &input.controls {
let mut array_139 = object.key("controls").start_array();
for item_140 in var_138 {
{
#[allow(unused_mut)]
let mut object_141 = array_139.value().start_object();
crate::json_ser::serialize_structure_crate_model_create_assessment_framework_control(&mut object_141, item_140)?;
object_141.finish();
}
}
array_139.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_create_control_mapping_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateControlMappingSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_142) = &input.source_name {
object.key("sourceName").string(var_142.as_str());
}
if let Some(var_143) = &input.source_description {
object.key("sourceDescription").string(var_143.as_str());
}
if let Some(var_144) = &input.source_set_up_option {
object.key("sourceSetUpOption").string(var_144.as_str());
}
if let Some(var_145) = &input.source_type {
object.key("sourceType").string(var_145.as_str());
}
if let Some(var_146) = &input.source_keyword {
#[allow(unused_mut)]
let mut object_147 = object.key("sourceKeyword").start_object();
crate::json_ser::serialize_structure_crate_model_source_keyword(&mut object_147, var_146)?;
object_147.finish();
}
if let Some(var_148) = &input.source_frequency {
object.key("sourceFrequency").string(var_148.as_str());
}
if let Some(var_149) = &input.troubleshooting_text {
object.key("troubleshootingText").string(var_149.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update_assessment_framework_control_set(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateAssessmentFrameworkControlSet,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_150) = &input.id {
object.key("id").string(var_150.as_str());
}
if let Some(var_151) = &input.name {
object.key("name").string(var_151.as_str());
}
if let Some(var_152) = &input.controls {
let mut array_153 = object.key("controls").start_array();
for item_154 in var_152 {
{
#[allow(unused_mut)]
let mut object_155 = array_153.value().start_object();
crate::json_ser::serialize_structure_crate_model_create_assessment_framework_control(&mut object_155, item_154)?;
object_155.finish();
}
}
array_153.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_control_mapping_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ControlMappingSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_156) = &input.source_id {
object.key("sourceId").string(var_156.as_str());
}
if let Some(var_157) = &input.source_name {
object.key("sourceName").string(var_157.as_str());
}
if let Some(var_158) = &input.source_description {
object.key("sourceDescription").string(var_158.as_str());
}
if let Some(var_159) = &input.source_set_up_option {
object.key("sourceSetUpOption").string(var_159.as_str());
}
if let Some(var_160) = &input.source_type {
object.key("sourceType").string(var_160.as_str());
}
if let Some(var_161) = &input.source_keyword {
#[allow(unused_mut)]
let mut object_162 = object.key("sourceKeyword").start_object();
crate::json_ser::serialize_structure_crate_model_source_keyword(&mut object_162, var_161)?;
object_162.finish();
}
if let Some(var_163) = &input.source_frequency {
object.key("sourceFrequency").string(var_163.as_str());
}
if let Some(var_164) = &input.troubleshooting_text {
object.key("troubleshootingText").string(var_164.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_deregistration_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeregistrationPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_165) = &input.delete_resources {
object.key("deleteResources").string(var_165.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_account(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsAccount,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_166) = &input.id {
object.key("id").string(var_166.as_str());
}
if let Some(var_167) = &input.email_address {
object.key("emailAddress").string(var_167.as_str());
}
if let Some(var_168) = &input.name {
object.key("name").string(var_168.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_service(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsService,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_169) = &input.service_name {
object.key("serviceName").string(var_169.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_create_assessment_framework_control(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateAssessmentFrameworkControl,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_170) = &input.id {
object.key("id").string(var_170.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_source_keyword(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SourceKeyword,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_171) = &input.keyword_input_type {
object.key("keywordInputType").string(var_171.as_str());
}
if let Some(var_172) = &input.keyword_value {
object.key("keywordValue").string(var_172.as_str());
}
Ok(())
}