// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
pub(crate) fn create_session_output_output_correct_errors(
    mut builder: crate::operation::create_session::builders::CreateSessionOutputBuilder,
) -> crate::operation::create_session::builders::CreateSessionOutputBuilder {
    if builder.credentials.is_none() {
        builder.credentials = {
            let builder = crate::types::builders::SessionCredentialsBuilder::default();
            crate::serde_util::session_credentials_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn get_bucket_tagging_output_output_correct_errors(
    mut builder: crate::operation::get_bucket_tagging::builders::GetBucketTaggingOutputBuilder,
) -> crate::operation::get_bucket_tagging::builders::GetBucketTaggingOutputBuilder {
    if builder.tag_set.is_none() {
        builder.tag_set = Some(Default::default())
    }
    builder
}

pub(crate) fn get_object_tagging_output_output_correct_errors(
    mut builder: crate::operation::get_object_tagging::builders::GetObjectTaggingOutputBuilder,
) -> crate::operation::get_object_tagging::builders::GetObjectTaggingOutputBuilder {
    if builder.tag_set.is_none() {
        builder.tag_set = Some(Default::default())
    }
    builder
}

pub(crate) fn session_credentials_correct_errors(
    mut builder: crate::types::builders::SessionCredentialsBuilder,
) -> crate::types::builders::SessionCredentialsBuilder {
    if builder.access_key_id.is_none() {
        builder.access_key_id = Some(Default::default())
    }
    if builder.secret_access_key.is_none() {
        builder.secret_access_key = Some(Default::default())
    }
    if builder.session_token.is_none() {
        builder.session_token = Some(Default::default())
    }
    if builder.expiration.is_none() {
        builder.expiration = Some(::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64))
    }
    builder
}

pub(crate) fn analytics_configuration_correct_errors(
    mut builder: crate::types::builders::AnalyticsConfigurationBuilder,
) -> crate::types::builders::AnalyticsConfigurationBuilder {
    if builder.id.is_none() {
        builder.id = Some(Default::default())
    }
    if builder.storage_class_analysis.is_none() {
        builder.storage_class_analysis = {
            let builder = crate::types::builders::StorageClassAnalysisBuilder::default();
            Some(builder.build())
        }
    }
    builder
}

pub(crate) fn cors_rule_correct_errors(mut builder: crate::types::builders::CorsRuleBuilder) -> crate::types::builders::CorsRuleBuilder {
    if builder.allowed_methods.is_none() {
        builder.allowed_methods = Some(Default::default())
    }
    if builder.allowed_origins.is_none() {
        builder.allowed_origins = Some(Default::default())
    }
    builder
}

pub(crate) fn error_document_correct_errors(
    mut builder: crate::types::builders::ErrorDocumentBuilder,
) -> crate::types::builders::ErrorDocumentBuilder {
    if builder.key.is_none() {
        builder.key = Some(Default::default())
    }
    builder
}

pub(crate) fn index_document_correct_errors(
    mut builder: crate::types::builders::IndexDocumentBuilder,
) -> crate::types::builders::IndexDocumentBuilder {
    if builder.suffix.is_none() {
        builder.suffix = Some(Default::default())
    }
    builder
}

pub(crate) fn intelligent_tiering_configuration_correct_errors(
    mut builder: crate::types::builders::IntelligentTieringConfigurationBuilder,
) -> crate::types::builders::IntelligentTieringConfigurationBuilder {
    if builder.id.is_none() {
        builder.id = Some(Default::default())
    }
    if builder.status.is_none() {
        builder.status = "no value was set".parse::<crate::types::IntelligentTieringStatus>().ok()
    }
    if builder.tierings.is_none() {
        builder.tierings = Some(Default::default())
    }
    builder
}

pub(crate) fn inventory_configuration_correct_errors(
    mut builder: crate::types::builders::InventoryConfigurationBuilder,
) -> crate::types::builders::InventoryConfigurationBuilder {
    if builder.destination.is_none() {
        builder.destination = {
            let builder = crate::types::builders::InventoryDestinationBuilder::default();
            Some(crate::serde_util::inventory_destination_correct_errors(builder).build())
        }
    }
    if builder.is_enabled.is_none() {
        builder.is_enabled = Some(Default::default())
    }
    if builder.id.is_none() {
        builder.id = Some(Default::default())
    }
    if builder.included_object_versions.is_none() {
        builder.included_object_versions = "no value was set".parse::<crate::types::InventoryIncludedObjectVersions>().ok()
    }
    if builder.schedule.is_none() {
        builder.schedule = {
            let builder = crate::types::builders::InventoryScheduleBuilder::default();
            crate::serde_util::inventory_schedule_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn lambda_function_configuration_correct_errors(
    mut builder: crate::types::builders::LambdaFunctionConfigurationBuilder,
) -> crate::types::builders::LambdaFunctionConfigurationBuilder {
    if builder.lambda_function_arn.is_none() {
        builder.lambda_function_arn = Some(Default::default())
    }
    if builder.events.is_none() {
        builder.events = Some(Default::default())
    }
    builder
}

pub(crate) fn lifecycle_rule_correct_errors(
    mut builder: crate::types::builders::LifecycleRuleBuilder,
) -> crate::types::builders::LifecycleRuleBuilder {
    if builder.status.is_none() {
        builder.status = "no value was set".parse::<crate::types::ExpirationStatus>().ok()
    }
    builder
}

pub(crate) fn logging_enabled_correct_errors(
    mut builder: crate::types::builders::LoggingEnabledBuilder,
) -> crate::types::builders::LoggingEnabledBuilder {
    if builder.target_bucket.is_none() {
        builder.target_bucket = Some(Default::default())
    }
    if builder.target_prefix.is_none() {
        builder.target_prefix = Some(Default::default())
    }
    builder
}

pub(crate) fn metrics_configuration_correct_errors(
    mut builder: crate::types::builders::MetricsConfigurationBuilder,
) -> crate::types::builders::MetricsConfigurationBuilder {
    if builder.id.is_none() {
        builder.id = Some(Default::default())
    }
    builder
}

pub(crate) fn queue_configuration_correct_errors(
    mut builder: crate::types::builders::QueueConfigurationBuilder,
) -> crate::types::builders::QueueConfigurationBuilder {
    if builder.queue_arn.is_none() {
        builder.queue_arn = Some(Default::default())
    }
    if builder.events.is_none() {
        builder.events = Some(Default::default())
    }
    builder
}

pub(crate) fn redirect_all_requests_to_correct_errors(
    mut builder: crate::types::builders::RedirectAllRequestsToBuilder,
) -> crate::types::builders::RedirectAllRequestsToBuilder {
    if builder.host_name.is_none() {
        builder.host_name = Some(Default::default())
    }
    builder
}

pub(crate) fn topic_configuration_correct_errors(
    mut builder: crate::types::builders::TopicConfigurationBuilder,
) -> crate::types::builders::TopicConfigurationBuilder {
    if builder.topic_arn.is_none() {
        builder.topic_arn = Some(Default::default())
    }
    if builder.events.is_none() {
        builder.events = Some(Default::default())
    }
    builder
}

pub(crate) fn get_bucket_metadata_table_configuration_result_correct_errors(
    mut builder: crate::types::builders::GetBucketMetadataTableConfigurationResultBuilder,
) -> crate::types::builders::GetBucketMetadataTableConfigurationResultBuilder {
    if builder.metadata_table_configuration_result.is_none() {
        builder.metadata_table_configuration_result = {
            let builder = crate::types::builders::MetadataTableConfigurationResultBuilder::default();
            Some(crate::serde_util::metadata_table_configuration_result_correct_errors(builder).build())
        }
    }
    if builder.status.is_none() {
        builder.status = Some(Default::default())
    }
    builder
}

pub(crate) fn inventory_destination_correct_errors(
    mut builder: crate::types::builders::InventoryDestinationBuilder,
) -> crate::types::builders::InventoryDestinationBuilder {
    if builder.s3_bucket_destination.is_none() {
        builder.s3_bucket_destination = {
            let builder = crate::types::builders::InventoryS3BucketDestinationBuilder::default();
            crate::serde_util::inventory_s3_bucket_destination_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn inventory_filter_correct_errors(
    mut builder: crate::types::builders::InventoryFilterBuilder,
) -> crate::types::builders::InventoryFilterBuilder {
    if builder.prefix.is_none() {
        builder.prefix = Some(Default::default())
    }
    builder
}

pub(crate) fn inventory_schedule_correct_errors(
    mut builder: crate::types::builders::InventoryScheduleBuilder,
) -> crate::types::builders::InventoryScheduleBuilder {
    if builder.frequency.is_none() {
        builder.frequency = "no value was set".parse::<crate::types::InventoryFrequency>().ok()
    }
    builder
}

pub(crate) fn ownership_controls_correct_errors(
    mut builder: crate::types::builders::OwnershipControlsBuilder,
) -> crate::types::builders::OwnershipControlsBuilder {
    if builder.rules.is_none() {
        builder.rules = Some(Default::default())
    }
    builder
}

pub(crate) fn replication_configuration_correct_errors(
    mut builder: crate::types::builders::ReplicationConfigurationBuilder,
) -> crate::types::builders::ReplicationConfigurationBuilder {
    if builder.role.is_none() {
        builder.role = Some(Default::default())
    }
    if builder.rules.is_none() {
        builder.rules = Some(Default::default())
    }
    builder
}

pub(crate) fn routing_rule_correct_errors(mut builder: crate::types::builders::RoutingRuleBuilder) -> crate::types::builders::RoutingRuleBuilder {
    if builder.redirect.is_none() {
        builder.redirect = {
            let builder = crate::types::builders::RedirectBuilder::default();
            Some(builder.build())
        }
    }
    builder
}

pub(crate) fn server_side_encryption_configuration_correct_errors(
    mut builder: crate::types::builders::ServerSideEncryptionConfigurationBuilder,
) -> crate::types::builders::ServerSideEncryptionConfigurationBuilder {
    if builder.rules.is_none() {
        builder.rules = Some(Default::default())
    }
    builder
}

pub(crate) fn tag_correct_errors(mut builder: crate::types::builders::TagBuilder) -> crate::types::builders::TagBuilder {
    if builder.key.is_none() {
        builder.key = Some(Default::default())
    }
    if builder.value.is_none() {
        builder.value = Some(Default::default())
    }
    builder
}

pub(crate) fn tiering_correct_errors(mut builder: crate::types::builders::TieringBuilder) -> crate::types::builders::TieringBuilder {
    if builder.days.is_none() {
        builder.days = Some(Default::default())
    }
    if builder.access_tier.is_none() {
        builder.access_tier = "no value was set".parse::<crate::types::IntelligentTieringAccessTier>().ok()
    }
    builder
}

pub(crate) fn grantee_correct_errors(mut builder: crate::types::builders::GranteeBuilder) -> crate::types::builders::GranteeBuilder {
    if builder.r#type.is_none() {
        builder.r#type = "no value was set".parse::<crate::types::Type>().ok()
    }
    builder
}

pub(crate) fn inventory_s3_bucket_destination_correct_errors(
    mut builder: crate::types::builders::InventoryS3BucketDestinationBuilder,
) -> crate::types::builders::InventoryS3BucketDestinationBuilder {
    if builder.bucket.is_none() {
        builder.bucket = Some(Default::default())
    }
    if builder.format.is_none() {
        builder.format = "no value was set".parse::<crate::types::InventoryFormat>().ok()
    }
    builder
}

pub(crate) fn metadata_table_configuration_result_correct_errors(
    mut builder: crate::types::builders::MetadataTableConfigurationResultBuilder,
) -> crate::types::builders::MetadataTableConfigurationResultBuilder {
    if builder.s3_tables_destination_result.is_none() {
        builder.s3_tables_destination_result = {
            let builder = crate::types::builders::S3TablesDestinationResultBuilder::default();
            crate::serde_util::s3_tables_destination_result_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn ownership_controls_rule_correct_errors(
    mut builder: crate::types::builders::OwnershipControlsRuleBuilder,
) -> crate::types::builders::OwnershipControlsRuleBuilder {
    if builder.object_ownership.is_none() {
        builder.object_ownership = "no value was set".parse::<crate::types::ObjectOwnership>().ok()
    }
    builder
}

pub(crate) fn replication_rule_correct_errors(
    mut builder: crate::types::builders::ReplicationRuleBuilder,
) -> crate::types::builders::ReplicationRuleBuilder {
    if builder.status.is_none() {
        builder.status = "no value was set".parse::<crate::types::ReplicationRuleStatus>().ok()
    }
    if builder.destination.is_none() {
        builder.destination = {
            let builder = crate::types::builders::DestinationBuilder::default();
            crate::serde_util::destination_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn storage_class_analysis_data_export_correct_errors(
    mut builder: crate::types::builders::StorageClassAnalysisDataExportBuilder,
) -> crate::types::builders::StorageClassAnalysisDataExportBuilder {
    if builder.output_schema_version.is_none() {
        builder.output_schema_version = "no value was set".parse::<crate::types::StorageClassAnalysisSchemaVersion>().ok()
    }
    if builder.destination.is_none() {
        builder.destination = {
            let builder = crate::types::builders::AnalyticsExportDestinationBuilder::default();
            Some(crate::serde_util::analytics_export_destination_correct_errors(builder).build())
        }
    }
    builder
}

pub(crate) fn analytics_export_destination_correct_errors(
    mut builder: crate::types::builders::AnalyticsExportDestinationBuilder,
) -> crate::types::builders::AnalyticsExportDestinationBuilder {
    if builder.s3_bucket_destination.is_none() {
        builder.s3_bucket_destination = {
            let builder = crate::types::builders::AnalyticsS3BucketDestinationBuilder::default();
            crate::serde_util::analytics_s3_bucket_destination_correct_errors(builder).build().ok()
        }
    }
    builder
}

pub(crate) fn destination_correct_errors(mut builder: crate::types::builders::DestinationBuilder) -> crate::types::builders::DestinationBuilder {
    if builder.bucket.is_none() {
        builder.bucket = Some(Default::default())
    }
    builder
}

pub(crate) fn existing_object_replication_correct_errors(
    mut builder: crate::types::builders::ExistingObjectReplicationBuilder,
) -> crate::types::builders::ExistingObjectReplicationBuilder {
    if builder.status.is_none() {
        builder.status = "no value was set".parse::<crate::types::ExistingObjectReplicationStatus>().ok()
    }
    builder
}

pub(crate) fn s3_tables_destination_result_correct_errors(
    mut builder: crate::types::builders::S3TablesDestinationResultBuilder,
) -> crate::types::builders::S3TablesDestinationResultBuilder {
    if builder.table_bucket_arn.is_none() {
        builder.table_bucket_arn = Some(Default::default())
    }
    if builder.table_name.is_none() {
        builder.table_name = Some(Default::default())
    }
    if builder.table_arn.is_none() {
        builder.table_arn = Some(Default::default())
    }
    if builder.table_namespace.is_none() {
        builder.table_namespace = Some(Default::default())
    }
    builder
}

pub(crate) fn server_side_encryption_by_default_correct_errors(
    mut builder: crate::types::builders::ServerSideEncryptionByDefaultBuilder,
) -> crate::types::builders::ServerSideEncryptionByDefaultBuilder {
    if builder.sse_algorithm.is_none() {
        builder.sse_algorithm = "no value was set".parse::<crate::types::ServerSideEncryption>().ok()
    }
    builder
}

pub(crate) fn access_control_translation_correct_errors(
    mut builder: crate::types::builders::AccessControlTranslationBuilder,
) -> crate::types::builders::AccessControlTranslationBuilder {
    if builder.owner.is_none() {
        builder.owner = "no value was set".parse::<crate::types::OwnerOverride>().ok()
    }
    builder
}

pub(crate) fn analytics_s3_bucket_destination_correct_errors(
    mut builder: crate::types::builders::AnalyticsS3BucketDestinationBuilder,
) -> crate::types::builders::AnalyticsS3BucketDestinationBuilder {
    if builder.format.is_none() {
        builder.format = "no value was set".parse::<crate::types::AnalyticsS3ExportFileFormat>().ok()
    }
    if builder.bucket.is_none() {
        builder.bucket = Some(Default::default())
    }
    builder
}

pub(crate) fn metrics_correct_errors(mut builder: crate::types::builders::MetricsBuilder) -> crate::types::builders::MetricsBuilder {
    if builder.status.is_none() {
        builder.status = "no value was set".parse::<crate::types::MetricsStatus>().ok()
    }
    builder
}

pub(crate) fn replica_modifications_correct_errors(
    mut builder: crate::types::builders::ReplicaModificationsBuilder,
) -> crate::types::builders::ReplicaModificationsBuilder {
    if builder.status.is_none() {
        builder.status = "no value was set".parse::<crate::types::ReplicaModificationsStatus>().ok()
    }
    builder
}

pub(crate) fn replication_time_correct_errors(
    mut builder: crate::types::builders::ReplicationTimeBuilder,
) -> crate::types::builders::ReplicationTimeBuilder {
    if builder.status.is_none() {
        builder.status = "no value was set".parse::<crate::types::ReplicationTimeStatus>().ok()
    }
    if builder.time.is_none() {
        builder.time = {
            let builder = crate::types::builders::ReplicationTimeValueBuilder::default();
            Some(builder.build())
        }
    }
    builder
}

pub(crate) fn sse_kms_encrypted_objects_correct_errors(
    mut builder: crate::types::builders::SseKmsEncryptedObjectsBuilder,
) -> crate::types::builders::SseKmsEncryptedObjectsBuilder {
    if builder.status.is_none() {
        builder.status = "no value was set".parse::<crate::types::SseKmsEncryptedObjectsStatus>().ok()
    }
    builder
}

pub(crate) fn ssekms_correct_errors(mut builder: crate::types::builders::SsekmsBuilder) -> crate::types::builders::SsekmsBuilder {
    if builder.key_id.is_none() {
        builder.key_id = Some(Default::default())
    }
    builder
}
