aws-sdk-ssoadmin 0.0.25-alpha

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub fn serialize_structure_crate_input_attach_managed_policy_to_permission_set_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::AttachManagedPolicyToPermissionSetInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_1) = &input.instance_arn {
        object.key("InstanceArn").string(var_1);
    }
    if let Some(var_2) = &input.permission_set_arn {
        object.key("PermissionSetArn").string(var_2);
    }
    if let Some(var_3) = &input.managed_policy_arn {
        object.key("ManagedPolicyArn").string(var_3);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_account_assignment_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateAccountAssignmentInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_4) = &input.instance_arn {
        object.key("InstanceArn").string(var_4);
    }
    if let Some(var_5) = &input.target_id {
        object.key("TargetId").string(var_5);
    }
    if let Some(var_6) = &input.target_type {
        object.key("TargetType").string(var_6.as_str());
    }
    if let Some(var_7) = &input.permission_set_arn {
        object.key("PermissionSetArn").string(var_7);
    }
    if let Some(var_8) = &input.principal_type {
        object.key("PrincipalType").string(var_8.as_str());
    }
    if let Some(var_9) = &input.principal_id {
        object.key("PrincipalId").string(var_9);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_instance_access_control_attribute_configuration_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreateInstanceAccessControlAttributeConfigurationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_10) = &input.instance_arn {
        object.key("InstanceArn").string(var_10);
    }
    if let Some(var_11) = &input.instance_access_control_attribute_configuration {
        let mut object_12 = object
            .key("InstanceAccessControlAttributeConfiguration")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_instance_access_control_attribute_configuration(&mut object_12, var_11)?;
        object_12.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_create_permission_set_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::CreatePermissionSetInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_13) = &input.name {
        object.key("Name").string(var_13);
    }
    if let Some(var_14) = &input.description {
        object.key("Description").string(var_14);
    }
    if let Some(var_15) = &input.instance_arn {
        object.key("InstanceArn").string(var_15);
    }
    if let Some(var_16) = &input.session_duration {
        object.key("SessionDuration").string(var_16);
    }
    if let Some(var_17) = &input.relay_state {
        object.key("RelayState").string(var_17);
    }
    if let Some(var_18) = &input.tags {
        let mut array_19 = object.key("Tags").start_array();
        for item_20 in var_18 {
            {
                let mut object_21 = array_19.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_21, item_20)?;
                object_21.finish();
            }
        }
        array_19.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_account_assignment_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteAccountAssignmentInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_22) = &input.instance_arn {
        object.key("InstanceArn").string(var_22);
    }
    if let Some(var_23) = &input.target_id {
        object.key("TargetId").string(var_23);
    }
    if let Some(var_24) = &input.target_type {
        object.key("TargetType").string(var_24.as_str());
    }
    if let Some(var_25) = &input.permission_set_arn {
        object.key("PermissionSetArn").string(var_25);
    }
    if let Some(var_26) = &input.principal_type {
        object.key("PrincipalType").string(var_26.as_str());
    }
    if let Some(var_27) = &input.principal_id {
        object.key("PrincipalId").string(var_27);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_inline_policy_from_permission_set_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteInlinePolicyFromPermissionSetInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_28) = &input.instance_arn {
        object.key("InstanceArn").string(var_28);
    }
    if let Some(var_29) = &input.permission_set_arn {
        object.key("PermissionSetArn").string(var_29);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_instance_access_control_attribute_configuration_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeleteInstanceAccessControlAttributeConfigurationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_30) = &input.instance_arn {
        object.key("InstanceArn").string(var_30);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_delete_permission_set_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DeletePermissionSetInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_31) = &input.instance_arn {
        object.key("InstanceArn").string(var_31);
    }
    if let Some(var_32) = &input.permission_set_arn {
        object.key("PermissionSetArn").string(var_32);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_account_assignment_creation_status_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeAccountAssignmentCreationStatusInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_33) = &input.instance_arn {
        object.key("InstanceArn").string(var_33);
    }
    if let Some(var_34) = &input.account_assignment_creation_request_id {
        object
            .key("AccountAssignmentCreationRequestId")
            .string(var_34);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_account_assignment_deletion_status_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeAccountAssignmentDeletionStatusInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_35) = &input.instance_arn {
        object.key("InstanceArn").string(var_35);
    }
    if let Some(var_36) = &input.account_assignment_deletion_request_id {
        object
            .key("AccountAssignmentDeletionRequestId")
            .string(var_36);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_instance_access_control_attribute_configuration_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribeInstanceAccessControlAttributeConfigurationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_37) = &input.instance_arn {
        object.key("InstanceArn").string(var_37);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_permission_set_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribePermissionSetInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_38) = &input.instance_arn {
        object.key("InstanceArn").string(var_38);
    }
    if let Some(var_39) = &input.permission_set_arn {
        object.key("PermissionSetArn").string(var_39);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_describe_permission_set_provisioning_status_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DescribePermissionSetProvisioningStatusInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_40) = &input.instance_arn {
        object.key("InstanceArn").string(var_40);
    }
    if let Some(var_41) = &input.provision_permission_set_request_id {
        object.key("ProvisionPermissionSetRequestId").string(var_41);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_detach_managed_policy_from_permission_set_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::DetachManagedPolicyFromPermissionSetInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_42) = &input.instance_arn {
        object.key("InstanceArn").string(var_42);
    }
    if let Some(var_43) = &input.permission_set_arn {
        object.key("PermissionSetArn").string(var_43);
    }
    if let Some(var_44) = &input.managed_policy_arn {
        object.key("ManagedPolicyArn").string(var_44);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_get_inline_policy_for_permission_set_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::GetInlinePolicyForPermissionSetInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_45) = &input.instance_arn {
        object.key("InstanceArn").string(var_45);
    }
    if let Some(var_46) = &input.permission_set_arn {
        object.key("PermissionSetArn").string(var_46);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_account_assignment_creation_status_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListAccountAssignmentCreationStatusInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_47) = &input.instance_arn {
        object.key("InstanceArn").string(var_47);
    }
    if let Some(var_48) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_48).into()),
        );
    }
    if let Some(var_49) = &input.next_token {
        object.key("NextToken").string(var_49);
    }
    if let Some(var_50) = &input.filter {
        let mut object_51 = object.key("Filter").start_object();
        crate::json_ser::serialize_structure_crate_model_operation_status_filter(
            &mut object_51,
            var_50,
        )?;
        object_51.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_account_assignment_deletion_status_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListAccountAssignmentDeletionStatusInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_52) = &input.instance_arn {
        object.key("InstanceArn").string(var_52);
    }
    if let Some(var_53) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_53).into()),
        );
    }
    if let Some(var_54) = &input.next_token {
        object.key("NextToken").string(var_54);
    }
    if let Some(var_55) = &input.filter {
        let mut object_56 = object.key("Filter").start_object();
        crate::json_ser::serialize_structure_crate_model_operation_status_filter(
            &mut object_56,
            var_55,
        )?;
        object_56.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_account_assignments_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListAccountAssignmentsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_57) = &input.instance_arn {
        object.key("InstanceArn").string(var_57);
    }
    if let Some(var_58) = &input.account_id {
        object.key("AccountId").string(var_58);
    }
    if let Some(var_59) = &input.permission_set_arn {
        object.key("PermissionSetArn").string(var_59);
    }
    if let Some(var_60) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_60).into()),
        );
    }
    if let Some(var_61) = &input.next_token {
        object.key("NextToken").string(var_61);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_accounts_for_provisioned_permission_set_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListAccountsForProvisionedPermissionSetInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_62) = &input.instance_arn {
        object.key("InstanceArn").string(var_62);
    }
    if let Some(var_63) = &input.permission_set_arn {
        object.key("PermissionSetArn").string(var_63);
    }
    if let Some(var_64) = &input.provisioning_status {
        object.key("ProvisioningStatus").string(var_64.as_str());
    }
    if let Some(var_65) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_65).into()),
        );
    }
    if let Some(var_66) = &input.next_token {
        object.key("NextToken").string(var_66);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_instances_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListInstancesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_67) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_67).into()),
        );
    }
    if let Some(var_68) = &input.next_token {
        object.key("NextToken").string(var_68);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_managed_policies_in_permission_set_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListManagedPoliciesInPermissionSetInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_69) = &input.instance_arn {
        object.key("InstanceArn").string(var_69);
    }
    if let Some(var_70) = &input.permission_set_arn {
        object.key("PermissionSetArn").string(var_70);
    }
    if let Some(var_71) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_71).into()),
        );
    }
    if let Some(var_72) = &input.next_token {
        object.key("NextToken").string(var_72);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_permission_set_provisioning_status_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListPermissionSetProvisioningStatusInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_73) = &input.instance_arn {
        object.key("InstanceArn").string(var_73);
    }
    if let Some(var_74) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_74).into()),
        );
    }
    if let Some(var_75) = &input.next_token {
        object.key("NextToken").string(var_75);
    }
    if let Some(var_76) = &input.filter {
        let mut object_77 = object.key("Filter").start_object();
        crate::json_ser::serialize_structure_crate_model_operation_status_filter(
            &mut object_77,
            var_76,
        )?;
        object_77.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_permission_sets_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListPermissionSetsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_78) = &input.instance_arn {
        object.key("InstanceArn").string(var_78);
    }
    if let Some(var_79) = &input.next_token {
        object.key("NextToken").string(var_79);
    }
    if let Some(var_80) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_80).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_permission_sets_provisioned_to_account_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListPermissionSetsProvisionedToAccountInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_81) = &input.instance_arn {
        object.key("InstanceArn").string(var_81);
    }
    if let Some(var_82) = &input.account_id {
        object.key("AccountId").string(var_82);
    }
    if let Some(var_83) = &input.provisioning_status {
        object.key("ProvisioningStatus").string(var_83.as_str());
    }
    if let Some(var_84) = &input.max_results {
        object.key("MaxResults").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_84).into()),
        );
    }
    if let Some(var_85) = &input.next_token {
        object.key("NextToken").string(var_85);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_list_tags_for_resource_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ListTagsForResourceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_86) = &input.instance_arn {
        object.key("InstanceArn").string(var_86);
    }
    if let Some(var_87) = &input.resource_arn {
        object.key("ResourceArn").string(var_87);
    }
    if let Some(var_88) = &input.next_token {
        object.key("NextToken").string(var_88);
    }
    Ok(())
}

pub fn serialize_structure_crate_input_provision_permission_set_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::ProvisionPermissionSetInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_89) = &input.instance_arn {
        object.key("InstanceArn").string(var_89);
    }
    if let Some(var_90) = &input.permission_set_arn {
        object.key("PermissionSetArn").string(var_90);
    }
    if let Some(var_91) = &input.target_id {
        object.key("TargetId").string(var_91);
    }
    if let Some(var_92) = &input.target_type {
        object.key("TargetType").string(var_92.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_input_put_inline_policy_to_permission_set_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::PutInlinePolicyToPermissionSetInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_93) = &input.instance_arn {
        object.key("InstanceArn").string(var_93);
    }
    if let Some(var_94) = &input.permission_set_arn {
        object.key("PermissionSetArn").string(var_94);
    }
    if let Some(var_95) = &input.inline_policy {
        object.key("InlinePolicy").string(var_95);
    }
    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_96) = &input.instance_arn {
        object.key("InstanceArn").string(var_96);
    }
    if let Some(var_97) = &input.resource_arn {
        object.key("ResourceArn").string(var_97);
    }
    if let Some(var_98) = &input.tags {
        let mut array_99 = object.key("Tags").start_array();
        for item_100 in var_98 {
            {
                let mut object_101 = array_99.value().start_object();
                crate::json_ser::serialize_structure_crate_model_tag(&mut object_101, item_100)?;
                object_101.finish();
            }
        }
        array_99.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_untag_resource_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UntagResourceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_102) = &input.instance_arn {
        object.key("InstanceArn").string(var_102);
    }
    if let Some(var_103) = &input.resource_arn {
        object.key("ResourceArn").string(var_103);
    }
    if let Some(var_104) = &input.tag_keys {
        let mut array_105 = object.key("TagKeys").start_array();
        for item_106 in var_104 {
            {
                array_105.value().string(item_106);
            }
        }
        array_105.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_instance_access_control_attribute_configuration_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdateInstanceAccessControlAttributeConfigurationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_107) = &input.instance_arn {
        object.key("InstanceArn").string(var_107);
    }
    if let Some(var_108) = &input.instance_access_control_attribute_configuration {
        let mut object_109 = object
            .key("InstanceAccessControlAttributeConfiguration")
            .start_object();
        crate::json_ser::serialize_structure_crate_model_instance_access_control_attribute_configuration(&mut object_109, var_108)?;
        object_109.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_input_update_permission_set_input(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::input::UpdatePermissionSetInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_110) = &input.instance_arn {
        object.key("InstanceArn").string(var_110);
    }
    if let Some(var_111) = &input.permission_set_arn {
        object.key("PermissionSetArn").string(var_111);
    }
    if let Some(var_112) = &input.description {
        object.key("Description").string(var_112);
    }
    if let Some(var_113) = &input.session_duration {
        object.key("SessionDuration").string(var_113);
    }
    if let Some(var_114) = &input.relay_state {
        object.key("RelayState").string(var_114);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_instance_access_control_attribute_configuration(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::InstanceAccessControlAttributeConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_115) = &input.access_control_attributes {
        let mut array_116 = object.key("AccessControlAttributes").start_array();
        for item_117 in var_115 {
            {
                let mut object_118 = array_116.value().start_object();
                crate::json_ser::serialize_structure_crate_model_access_control_attribute(
                    &mut object_118,
                    item_117,
                )?;
                object_118.finish();
            }
        }
        array_116.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_tag(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_119) = &input.key {
        object.key("Key").string(var_119);
    }
    if let Some(var_120) = &input.value {
        object.key("Value").string(var_120);
    }
    Ok(())
}

pub fn serialize_structure_crate_model_operation_status_filter(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::OperationStatusFilter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_121) = &input.status {
        object.key("Status").string(var_121.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_access_control_attribute(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AccessControlAttribute,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_122) = &input.key {
        object.key("Key").string(var_122);
    }
    if let Some(var_123) = &input.value {
        let mut object_124 = object.key("Value").start_object();
        crate::json_ser::serialize_structure_crate_model_access_control_attribute_value(
            &mut object_124,
            var_123,
        )?;
        object_124.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_access_control_attribute_value(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AccessControlAttributeValue,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
    if let Some(var_125) = &input.source {
        let mut array_126 = object.key("Source").start_array();
        for item_127 in var_125 {
            {
                array_126.value().string(item_127);
            }
        }
        array_126.finish();
    }
    Ok(())
}