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::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::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::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 {
{
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::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::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::SerializationError> {
if let Some(var_17) = &input.manual_evidence {
let mut array_18 = object.key("manualEvidence").start_array();
for item_19 in var_17 {
{
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::SerializationError> {
if let Some(var_21) = &input.assessment_reports_destination {
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 {
{
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 {
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 {
let mut object_33 = object.key("tags").start_object();
for (key_34, value_35) in var_32 {
{
object_33.key(key_34).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::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 {
{
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 {
let mut object_44 = object.key("tags").start_object();
for (key_45, value_46) in var_43 {
{
object_44.key(key_45).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::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());
}
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::SerializationError> {
if let Some(var_49) = &input.action_plan_instructions {
object.key("actionPlanInstructions").string(var_49.as_str());
}
if let Some(var_50) = &input.action_plan_title {
object.key("actionPlanTitle").string(var_50.as_str());
}
if let Some(var_51) = &input.control_mapping_sources {
let mut array_52 = object.key("controlMappingSources").start_array();
for item_53 in var_51 {
{
let mut object_54 = array_52.value().start_object();
crate::json_ser::serialize_structure_crate_model_create_control_mapping_source(
&mut object_54,
item_53,
)?;
object_54.finish();
}
}
array_52.finish();
}
if let Some(var_55) = &input.description {
object.key("description").string(var_55.as_str());
}
if let Some(var_56) = &input.name {
object.key("name").string(var_56.as_str());
}
if let Some(var_57) = &input.tags {
let mut object_58 = object.key("tags").start_object();
for (key_59, value_60) in var_57 {
{
object_58.key(key_59).string(value_60.as_str());
}
}
object_58.finish();
}
if let Some(var_61) = &input.testing_information {
object.key("testingInformation").string(var_61.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::SerializationError> {
if let Some(var_62) = &input.admin_account_id {
object.key("adminAccountId").string(var_62.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::SerializationError> {
if let Some(var_63) = &input.evidence_folder_id {
object.key("evidenceFolderId").string(var_63.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::SerializationError> {
if let Some(var_64) = &input.delegated_admin_account {
object.key("delegatedAdminAccount").string(var_64.as_str());
}
if let Some(var_65) = &input.kms_key {
object.key("kmsKey").string(var_65.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::SerializationError> {
if let Some(var_66) = &input.admin_account_id {
object.key("adminAccountId").string(var_66.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::SerializationError> {
if let Some(var_67) = &input.comment {
object.key("comment").string(var_67.as_str());
}
if let Some(var_68) = &input.destination_account {
object.key("destinationAccount").string(var_68.as_str());
}
if let Some(var_69) = &input.destination_region {
object.key("destinationRegion").string(var_69.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::SerializationError> {
if let Some(var_70) = &input.tags {
let mut object_71 = object.key("tags").start_object();
for (key_72, value_73) in var_70 {
{
object_71.key(key_72).string(value_73.as_str());
}
}
object_71.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::SerializationError> {
if let Some(var_74) = &input.assessment_description {
object.key("assessmentDescription").string(var_74.as_str());
}
if let Some(var_75) = &input.assessment_name {
object.key("assessmentName").string(var_75.as_str());
}
if let Some(var_76) = &input.assessment_reports_destination {
let mut object_77 = object.key("assessmentReportsDestination").start_object();
crate::json_ser::serialize_structure_crate_model_assessment_reports_destination(
&mut object_77,
var_76,
)?;
object_77.finish();
}
if let Some(var_78) = &input.roles {
let mut array_79 = object.key("roles").start_array();
for item_80 in var_78 {
{
let mut object_81 = array_79.value().start_object();
crate::json_ser::serialize_structure_crate_model_role(&mut object_81, item_80)?;
object_81.finish();
}
}
array_79.finish();
}
if let Some(var_82) = &input.scope {
let mut object_83 = object.key("scope").start_object();
crate::json_ser::serialize_structure_crate_model_scope(&mut object_83, var_82)?;
object_83.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::SerializationError> {
if let Some(var_84) = &input.comment_body {
object.key("commentBody").string(var_84.as_str());
}
if let Some(var_85) = &input.control_status {
object.key("controlStatus").string(var_85.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::SerializationError> {
if let Some(var_86) = &input.comment {
object.key("comment").string(var_86.as_str());
}
if let Some(var_87) = &input.status {
object.key("status").string(var_87.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::SerializationError> {
if let Some(var_88) = &input.compliance_type {
object.key("complianceType").string(var_88.as_str());
}
if let Some(var_89) = &input.control_sets {
let mut array_90 = object.key("controlSets").start_array();
for item_91 in var_89 {
{
let mut object_92 = array_90.value().start_object();
crate::json_ser::serialize_structure_crate_model_update_assessment_framework_control_set(&mut object_92, item_91)?;
object_92.finish();
}
}
array_90.finish();
}
if let Some(var_93) = &input.description {
object.key("description").string(var_93.as_str());
}
if let Some(var_94) = &input.name {
object.key("name").string(var_94.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::SerializationError> {
if let Some(var_95) = &input.action {
object.key("action").string(var_95.as_str());
}
if let Some(var_96) = &input.request_type {
object.key("requestType").string(var_96.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::SerializationError> {
if let Some(var_97) = &input.status {
object.key("status").string(var_97.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::SerializationError> {
if let Some(var_98) = &input.action_plan_instructions {
object.key("actionPlanInstructions").string(var_98.as_str());
}
if let Some(var_99) = &input.action_plan_title {
object.key("actionPlanTitle").string(var_99.as_str());
}
if let Some(var_100) = &input.control_mapping_sources {
let mut array_101 = object.key("controlMappingSources").start_array();
for item_102 in var_100 {
{
let mut object_103 = array_101.value().start_object();
crate::json_ser::serialize_structure_crate_model_control_mapping_source(
&mut object_103,
item_102,
)?;
object_103.finish();
}
}
array_101.finish();
}
if let Some(var_104) = &input.description {
object.key("description").string(var_104.as_str());
}
if let Some(var_105) = &input.name {
object.key("name").string(var_105.as_str());
}
if let Some(var_106) = &input.testing_information {
object.key("testingInformation").string(var_106.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::SerializationError> {
if let Some(var_107) = &input.default_assessment_reports_destination {
let mut object_108 = object
.key("defaultAssessmentReportsDestination")
.start_object();
crate::json_ser::serialize_structure_crate_model_assessment_reports_destination(
&mut object_108,
var_107,
)?;
object_108.finish();
}
if let Some(var_109) = &input.default_process_owners {
let mut array_110 = object.key("defaultProcessOwners").start_array();
for item_111 in var_109 {
{
let mut object_112 = array_110.value().start_object();
crate::json_ser::serialize_structure_crate_model_role(&mut object_112, item_111)?;
object_112.finish();
}
}
array_110.finish();
}
if let Some(var_113) = &input.kms_key {
object.key("kmsKey").string(var_113.as_str());
}
if let Some(var_114) = &input.sns_topic {
object.key("snsTopic").string(var_114.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::SerializationError> {
if let Some(var_115) = &input.s3_relative_path {
object.key("s3RelativePath").string(var_115.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::SerializationError> {
if let Some(var_116) = &input.comment {
object.key("comment").string(var_116.as_str());
}
if let Some(var_117) = &input.control_set_id {
object.key("controlSetId").string(var_117.as_str());
}
if let Some(var_118) = &input.role_arn {
object.key("roleArn").string(var_118.as_str());
}
if let Some(var_119) = &input.role_type {
object.key("roleType").string(var_119.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::SerializationError> {
if let Some(var_120) = &input.s3_resource_path {
object.key("s3ResourcePath").string(var_120.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::SerializationError> {
if let Some(var_121) = &input.destination_type {
object.key("destinationType").string(var_121.as_str());
}
if let Some(var_122) = &input.destination {
object.key("destination").string(var_122.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::SerializationError> {
if let Some(var_123) = &input.role_type {
object.key("roleType").string(var_123.as_str());
}
if let Some(var_124) = &input.role_arn {
object.key("roleArn").string(var_124.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::SerializationError> {
if let Some(var_125) = &input.aws_accounts {
let mut array_126 = object.key("awsAccounts").start_array();
for item_127 in var_125 {
{
let mut object_128 = array_126.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_account(
&mut object_128,
item_127,
)?;
object_128.finish();
}
}
array_126.finish();
}
if let Some(var_129) = &input.aws_services {
let mut array_130 = object.key("awsServices").start_array();
for item_131 in var_129 {
{
let mut object_132 = array_130.value().start_object();
crate::json_ser::serialize_structure_crate_model_aws_service(
&mut object_132,
item_131,
)?;
object_132.finish();
}
}
array_130.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::SerializationError> {
if let Some(var_133) = &input.name {
object.key("name").string(var_133.as_str());
}
if let Some(var_134) = &input.controls {
let mut array_135 = object.key("controls").start_array();
for item_136 in var_134 {
{
let mut object_137 = array_135.value().start_object();
crate::json_ser::serialize_structure_crate_model_create_assessment_framework_control(&mut object_137, item_136)?;
object_137.finish();
}
}
array_135.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::SerializationError> {
if let Some(var_138) = &input.source_name {
object.key("sourceName").string(var_138.as_str());
}
if let Some(var_139) = &input.source_description {
object.key("sourceDescription").string(var_139.as_str());
}
if let Some(var_140) = &input.source_set_up_option {
object.key("sourceSetUpOption").string(var_140.as_str());
}
if let Some(var_141) = &input.source_type {
object.key("sourceType").string(var_141.as_str());
}
if let Some(var_142) = &input.source_keyword {
let mut object_143 = object.key("sourceKeyword").start_object();
crate::json_ser::serialize_structure_crate_model_source_keyword(&mut object_143, var_142)?;
object_143.finish();
}
if let Some(var_144) = &input.source_frequency {
object.key("sourceFrequency").string(var_144.as_str());
}
if let Some(var_145) = &input.troubleshooting_text {
object.key("troubleshootingText").string(var_145.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::SerializationError> {
if let Some(var_146) = &input.id {
object.key("id").string(var_146.as_str());
}
if let Some(var_147) = &input.name {
object.key("name").string(var_147.as_str());
}
if let Some(var_148) = &input.controls {
let mut array_149 = object.key("controls").start_array();
for item_150 in var_148 {
{
let mut object_151 = array_149.value().start_object();
crate::json_ser::serialize_structure_crate_model_create_assessment_framework_control(&mut object_151, item_150)?;
object_151.finish();
}
}
array_149.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::SerializationError> {
if let Some(var_152) = &input.source_id {
object.key("sourceId").string(var_152.as_str());
}
if let Some(var_153) = &input.source_name {
object.key("sourceName").string(var_153.as_str());
}
if let Some(var_154) = &input.source_description {
object.key("sourceDescription").string(var_154.as_str());
}
if let Some(var_155) = &input.source_set_up_option {
object.key("sourceSetUpOption").string(var_155.as_str());
}
if let Some(var_156) = &input.source_type {
object.key("sourceType").string(var_156.as_str());
}
if let Some(var_157) = &input.source_keyword {
let mut object_158 = object.key("sourceKeyword").start_object();
crate::json_ser::serialize_structure_crate_model_source_keyword(&mut object_158, var_157)?;
object_158.finish();
}
if let Some(var_159) = &input.source_frequency {
object.key("sourceFrequency").string(var_159.as_str());
}
if let Some(var_160) = &input.troubleshooting_text {
object.key("troubleshootingText").string(var_160.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::SerializationError> {
if let Some(var_161) = &input.id {
object.key("id").string(var_161.as_str());
}
if let Some(var_162) = &input.email_address {
object.key("emailAddress").string(var_162.as_str());
}
if let Some(var_163) = &input.name {
object.key("name").string(var_163.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::SerializationError> {
if let Some(var_164) = &input.service_name {
object.key("serviceName").string(var_164.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::SerializationError> {
if let Some(var_165) = &input.id {
object.key("id").string(var_165.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::SerializationError> {
if let Some(var_166) = &input.keyword_input_type {
object.key("keywordInputType").string(var_166.as_str());
}
if let Some(var_167) = &input.keyword_value {
object.key("keywordValue").string(var_167.as_str());
}
Ok(())
}