oci 2.16.0 → 2.17.0

data/lib/oci/data_safe/data_safe_client_composite_operations.rb

@@ -75,20 +75,19 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#change_data_safe_private_endpoint_compartment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#add_masking_columns_from_sdm} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [String] data_safe_private_endpoint_id The OCID of the private endpoint.
-    # @param [OCI::DataSafe::Models::ChangeDataSafePrivateEndpointCompartmentDetails] change_data_safe_private_endpoint_compartment_details The details used to change the compartment of a Data Safe private endpoint.
+    # @param [String] masking_policy_id The OCID of the masking policy.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#change_data_safe_private_endpoint_compartment}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#add_masking_columns_from_sdm}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def change_data_safe_private_endpoint_compartment_and_wait_for_state(data_safe_private_endpoint_id, change_data_safe_private_endpoint_compartment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.change_data_safe_private_endpoint_compartment(data_safe_private_endpoint_id, change_data_safe_private_endpoint_compartment_details, base_operation_opts)
+    def add_masking_columns_from_sdm_and_wait_for_state(masking_policy_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.add_masking_columns_from_sdm(masking_policy_id, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -125,20 +124,20 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#compare_security_assessment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#apply_discovery_job_results} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [String] security_assessment_id The OCID of the security assessment.
-    # @param [OCI::DataSafe::Models::CompareSecurityAssessmentDetails] compare_security_assessment_details Details of the security assessment comparison.
+    # @param [String] sensitive_data_model_id The OCID of the sensitive data model.
+    # @param [OCI::DataSafe::Models::ApplyDiscoveryJobResultsDetails] apply_discovery_job_results_details Details to apply the discovery results to a sensitive data model.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#compare_security_assessment}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#apply_discovery_job_results}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def compare_security_assessment_and_wait_for_state(security_assessment_id, compare_security_assessment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.compare_security_assessment(security_assessment_id, compare_security_assessment_details, base_operation_opts)
+    def apply_discovery_job_results_and_wait_for_state(sensitive_data_model_id, apply_discovery_job_results_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.apply_discovery_job_results(sensitive_data_model_id, apply_discovery_job_results_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -175,20 +174,20 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#compare_user_assessment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#calculate_audit_volume_available} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [String] user_assessment_id The OCID of the user assessment.
-    # @param [OCI::DataSafe::Models::CompareUserAssessmentDetails] compare_user_assessment_details Details of the user assessment comparison.
+    # @param [String] audit_profile_id The OCID of the audit.
+    # @param [OCI::DataSafe::Models::CalculateAuditVolumeAvailableDetails] calculate_audit_volume_available_details Details for the calculation of audit volume available on target database.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#compare_user_assessment}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#calculate_audit_volume_available}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def compare_user_assessment_and_wait_for_state(user_assessment_id, compare_user_assessment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.compare_user_assessment(user_assessment_id, compare_user_assessment_details, base_operation_opts)
+    def calculate_audit_volume_available_and_wait_for_state(audit_profile_id, calculate_audit_volume_available_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.calculate_audit_volume_available(audit_profile_id, calculate_audit_volume_available_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -225,19 +224,20 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#create_data_safe_private_endpoint} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#calculate_audit_volume_collected} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [OCI::DataSafe::Models::CreateDataSafePrivateEndpointDetails] create_data_safe_private_endpoint_details Details to create a new private endpoint.
+    # @param [String] audit_profile_id The OCID of the audit.
+    # @param [OCI::DataSafe::Models::CalculateAuditVolumeCollectedDetails] calculate_audit_volume_collected_details Details for the calculation of audit volume collected by data safe.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#create_data_safe_private_endpoint}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#calculate_audit_volume_collected}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def create_data_safe_private_endpoint_and_wait_for_state(create_data_safe_private_endpoint_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.create_data_safe_private_endpoint(create_data_safe_private_endpoint_details, base_operation_opts)
+    def calculate_audit_volume_collected_and_wait_for_state(audit_profile_id, calculate_audit_volume_collected_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.calculate_audit_volume_collected(audit_profile_id, calculate_audit_volume_collected_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -274,19 +274,20 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#create_on_prem_connector} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#change_audit_archive_retrieval_compartment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [OCI::DataSafe::Models::CreateOnPremConnectorDetails] create_on_prem_connector_details The details used to create a new on-premises connector.
+    # @param [String] audit_archive_retrieval_id OCID of the archive retrieval.
+    # @param [OCI::DataSafe::Models::ChangeAuditArchiveRetrievalCompartmentDetails] change_audit_archive_retrieval_compartment_details The details used to change the compartment of a archive retrieval.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#create_on_prem_connector}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#change_audit_archive_retrieval_compartment}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def create_on_prem_connector_and_wait_for_state(create_on_prem_connector_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.create_on_prem_connector(create_on_prem_connector_details, base_operation_opts)
+    def change_audit_archive_retrieval_compartment_and_wait_for_state(audit_archive_retrieval_id, change_audit_archive_retrieval_compartment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.change_audit_archive_retrieval_compartment(audit_archive_retrieval_id, change_audit_archive_retrieval_compartment_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -323,19 +324,20 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#create_security_assessment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#change_audit_policy_compartment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [OCI::DataSafe::Models::CreateSecurityAssessmentDetails] create_security_assessment_details The details used to create a new saved security assessment.
+    # @param [String] audit_policy_id Unique audit policy identifier.
+    # @param [OCI::DataSafe::Models::ChangeAuditPolicyCompartmentDetails] change_audit_policy_compartment_details Details for the compartment move.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#create_security_assessment}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#change_audit_policy_compartment}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def create_security_assessment_and_wait_for_state(create_security_assessment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.create_security_assessment(create_security_assessment_details, base_operation_opts)
+    def change_audit_policy_compartment_and_wait_for_state(audit_policy_id, change_audit_policy_compartment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.change_audit_policy_compartment(audit_policy_id, change_audit_policy_compartment_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -372,19 +374,20 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#create_target_database} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#change_audit_profile_compartment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [OCI::DataSafe::Models::CreateTargetDatabaseDetails] create_target_database_details Details of the target database.
+    # @param [String] audit_profile_id The OCID of the audit.
+    # @param [OCI::DataSafe::Models::ChangeAuditProfileCompartmentDetails] change_audit_profile_compartment_details Details for the compartment move.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#create_target_database}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#change_audit_profile_compartment}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def create_target_database_and_wait_for_state(create_target_database_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.create_target_database(create_target_database_details, base_operation_opts)
+    def change_audit_profile_compartment_and_wait_for_state(audit_profile_id, change_audit_profile_compartment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.change_audit_profile_compartment(audit_profile_id, change_audit_profile_compartment_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -421,19 +424,20 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#create_user_assessment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#change_data_safe_private_endpoint_compartment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [OCI::DataSafe::Models::CreateUserAssessmentDetails] create_user_assessment_details The details used to create a new saved user assessment.
+    # @param [String] data_safe_private_endpoint_id The OCID of the private endpoint.
+    # @param [OCI::DataSafe::Models::ChangeDataSafePrivateEndpointCompartmentDetails] change_data_safe_private_endpoint_compartment_details The details used to change the compartment of a Data Safe private endpoint.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#create_user_assessment}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#change_data_safe_private_endpoint_compartment}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def create_user_assessment_and_wait_for_state(create_user_assessment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.create_user_assessment(create_user_assessment_details, base_operation_opts)
+    def change_data_safe_private_endpoint_compartment_and_wait_for_state(data_safe_private_endpoint_id, change_data_safe_private_endpoint_compartment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.change_data_safe_private_endpoint_compartment(data_safe_private_endpoint_id, change_data_safe_private_endpoint_compartment_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -470,19 +474,20 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#deactivate_target_database} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#change_report_compartment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [String] target_database_id The OCID of the Data Safe target database.
+    # @param [String] report_id Unique report identifier
+    # @param [OCI::DataSafe::Models::ChangeReportCompartmentDetails] change_report_compartment_details Details for the different Report.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#deactivate_target_database}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#change_report_compartment}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def deactivate_target_database_and_wait_for_state(target_database_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.deactivate_target_database(target_database_id, base_operation_opts)
+    def change_report_compartment_and_wait_for_state(report_id, change_report_compartment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.change_report_compartment(report_id, change_report_compartment_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -519,19 +524,20 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#delete_data_safe_private_endpoint} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#change_report_definition_compartment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [String] data_safe_private_endpoint_id The OCID of the private endpoint.
+    # @param [String] report_definition_id Unique report definition identifier
+    # @param [OCI::DataSafe::Models::ChangeReportDefinitionCompartmentDetails] change_report_definition_compartment_details Details for the different ReportDefinition.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#delete_data_safe_private_endpoint}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#change_report_definition_compartment}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def delete_data_safe_private_endpoint_and_wait_for_state(data_safe_private_endpoint_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.delete_data_safe_private_endpoint(data_safe_private_endpoint_id, base_operation_opts)
+    def change_report_definition_compartment_and_wait_for_state(report_definition_id, change_report_definition_compartment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.change_report_definition_compartment(report_definition_id, change_report_definition_compartment_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -568,19 +574,20 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#delete_on_prem_connector} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#change_retention} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [String] on_prem_connector_id The OCID of the on-premises connector.
+    # @param [String] audit_profile_id The OCID of the audit.
+    # @param [OCI::DataSafe::Models::ChangeRetentionDetails] change_retention_details Details for the audit retention months to be modified.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#delete_on_prem_connector}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#change_retention}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def delete_on_prem_connector_and_wait_for_state(on_prem_connector_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.delete_on_prem_connector(on_prem_connector_id, base_operation_opts)
+    def change_retention_and_wait_for_state(audit_profile_id, change_retention_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.change_retention(audit_profile_id, change_retention_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -617,19 +624,20 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#delete_security_assessment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#compare_security_assessment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
     # @param [String] security_assessment_id The OCID of the security assessment.
+    # @param [OCI::DataSafe::Models::CompareSecurityAssessmentDetails] compare_security_assessment_details Details of the security assessment comparison.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#delete_security_assessment}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#compare_security_assessment}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def delete_security_assessment_and_wait_for_state(security_assessment_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.delete_security_assessment(security_assessment_id, base_operation_opts)
+    def compare_security_assessment_and_wait_for_state(security_assessment_id, compare_security_assessment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.compare_security_assessment(security_assessment_id, compare_security_assessment_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -666,19 +674,20 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#delete_target_database} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#compare_user_assessment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [String] target_database_id The OCID of the Data Safe target database.
+    # @param [String] user_assessment_id The OCID of the user assessment.
+    # @param [OCI::DataSafe::Models::CompareUserAssessmentDetails] compare_user_assessment_details Details of the user assessment comparison.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#delete_target_database}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#compare_user_assessment}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def delete_target_database_and_wait_for_state(target_database_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.delete_target_database(target_database_id, base_operation_opts)
+    def compare_user_assessment_and_wait_for_state(user_assessment_id, compare_user_assessment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.compare_user_assessment(user_assessment_id, compare_user_assessment_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -715,19 +724,19 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#delete_user_assessment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#create_audit_archive_retrieval} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [String] user_assessment_id The OCID of the user assessment.
+    # @param [OCI::DataSafe::Models::CreateAuditArchiveRetrievalDetails] create_audit_archive_retrieval_details Details for creating retrieving archived audit data.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#delete_user_assessment}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#create_audit_archive_retrieval}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def delete_user_assessment_and_wait_for_state(user_assessment_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.delete_user_assessment(user_assessment_id, base_operation_opts)
+    def create_audit_archive_retrieval_and_wait_for_state(create_audit_archive_retrieval_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.create_audit_archive_retrieval(create_audit_archive_retrieval_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -764,19 +773,19 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#enable_data_safe_configuration} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#create_data_safe_private_endpoint} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [OCI::DataSafe::Models::EnableDataSafeConfigurationDetails] enable_data_safe_configuration_details The details used to enable Data Safe.
+    # @param [OCI::DataSafe::Models::CreateDataSafePrivateEndpointDetails] create_data_safe_private_endpoint_details Details to create a new private endpoint.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#enable_data_safe_configuration}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#create_data_safe_private_endpoint}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def enable_data_safe_configuration_and_wait_for_state(enable_data_safe_configuration_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.enable_data_safe_configuration(enable_data_safe_configuration_details, base_operation_opts)
+    def create_data_safe_private_endpoint_and_wait_for_state(create_data_safe_private_endpoint_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.create_data_safe_private_endpoint(create_data_safe_private_endpoint_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -813,20 +822,19 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#generate_security_assessment_report} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#create_discovery_job} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [String] security_assessment_id The OCID of the security assessment.
-    # @param [OCI::DataSafe::Models::GenerateSecurityAssessmentReportDetails] generate_security_assessment_report_details Details of the report.
+    # @param [OCI::DataSafe::Models::CreateDiscoveryJobDetails] create_discovery_job_details The details used to run an incremental data discovery job
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#generate_security_assessment_report}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#create_discovery_job}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def generate_security_assessment_report_and_wait_for_state(security_assessment_id, generate_security_assessment_report_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.generate_security_assessment_report(security_assessment_id, generate_security_assessment_report_details, base_operation_opts)
+    def create_discovery_job_and_wait_for_state(create_discovery_job_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.create_discovery_job(create_discovery_job_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -863,20 +871,19 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#generate_user_assessment_report} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#create_library_masking_format} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [String] user_assessment_id The OCID of the user assessment.
-    # @param [OCI::DataSafe::Models::GenerateUserAssessmentReportDetails] generate_user_assessment_report_details Details of the report.
+    # @param [OCI::DataSafe::Models::CreateLibraryMaskingFormatDetails] create_library_masking_format_details Details to create a new library masking format.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#generate_user_assessment_report}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#create_library_masking_format}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def generate_user_assessment_report_and_wait_for_state(user_assessment_id, generate_user_assessment_report_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.generate_user_assessment_report(user_assessment_id, generate_user_assessment_report_details, base_operation_opts)
+    def create_library_masking_format_and_wait_for_state(create_library_masking_format_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.create_library_masking_format(create_library_masking_format_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -913,20 +920,20 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#refresh_security_assessment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#create_masking_column} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [String] security_assessment_id The OCID of the security assessment.
-    # @param [OCI::DataSafe::Models::RunSecurityAssessmentDetails] run_security_assessment_details Details to create an on-demand saved security assessment.
+    # @param [OCI::DataSafe::Models::CreateMaskingColumnDetails] create_masking_column_details Details to create a new masking column.
+    # @param [String] masking_policy_id The OCID of the masking policy.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#refresh_security_assessment}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#create_masking_column}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def refresh_security_assessment_and_wait_for_state(security_assessment_id, run_security_assessment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.refresh_security_assessment(security_assessment_id, run_security_assessment_details, base_operation_opts)
+    def create_masking_column_and_wait_for_state(create_masking_column_details, masking_policy_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.create_masking_column(create_masking_column_details, masking_policy_id, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -963,20 +970,19 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#refresh_user_assessment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#create_masking_policy} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [String] user_assessment_id The OCID of the user assessment.
-    # @param [OCI::DataSafe::Models::RunUserAssessmentDetails] run_user_assessment_details The details required to create an on-demand saved user assessment.
+    # @param [OCI::DataSafe::Models::CreateMaskingPolicyDetails] create_masking_policy_details Details to create a new masking policy.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#refresh_user_assessment}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#create_masking_policy}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def refresh_user_assessment_and_wait_for_state(user_assessment_id, run_user_assessment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.refresh_user_assessment(user_assessment_id, run_user_assessment_details, base_operation_opts)
+    def create_masking_policy_and_wait_for_state(create_masking_policy_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.create_masking_policy(create_masking_policy_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -1013,19 +1019,19 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#set_security_assessment_baseline} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#create_on_prem_connector} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [String] security_assessment_id The OCID of the security assessment.
+    # @param [OCI::DataSafe::Models::CreateOnPremConnectorDetails] create_on_prem_connector_details The details used to create a new on-premises connector.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#set_security_assessment_baseline}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#create_on_prem_connector}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def set_security_assessment_baseline_and_wait_for_state(security_assessment_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.set_security_assessment_baseline(security_assessment_id, base_operation_opts)
+    def create_on_prem_connector_and_wait_for_state(create_on_prem_connector_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.create_on_prem_connector(create_on_prem_connector_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -1062,19 +1068,19 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#set_user_assessment_baseline} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#create_report_definition} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [String] user_assessment_id The OCID of the user assessment.
+    # @param [OCI::DataSafe::Models::CreateReportDefinitionDetails] create_report_definition_details Details for the new report definition.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#set_user_assessment_baseline}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#create_report_definition}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def set_user_assessment_baseline_and_wait_for_state(user_assessment_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.set_user_assessment_baseline(user_assessment_id, base_operation_opts)
+    def create_report_definition_and_wait_for_state(create_report_definition_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.create_report_definition(create_report_definition_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -1111,19 +1117,19 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#unset_security_assessment_baseline} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#create_security_assessment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [String] security_assessment_id The OCID of the security assessment.
+    # @param [OCI::DataSafe::Models::CreateSecurityAssessmentDetails] create_security_assessment_details The details used to create a new saved security assessment.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#unset_security_assessment_baseline}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#create_security_assessment}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def unset_security_assessment_baseline_and_wait_for_state(security_assessment_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.unset_security_assessment_baseline(security_assessment_id, base_operation_opts)
+    def create_security_assessment_and_wait_for_state(create_security_assessment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.create_security_assessment(create_security_assessment_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -1160,19 +1166,20 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#unset_user_assessment_baseline} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#create_sensitive_column} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [String] user_assessment_id The OCID of the user assessment.
+    # @param [String] sensitive_data_model_id The OCID of the sensitive data model.
+    # @param [OCI::DataSafe::Models::CreateSensitiveColumnDetails] create_sensitive_column_details Details to create a new sensitive column.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#unset_user_assessment_baseline}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#create_sensitive_column}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def unset_user_assessment_baseline_and_wait_for_state(user_assessment_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.unset_user_assessment_baseline(user_assessment_id, base_operation_opts)
+    def create_sensitive_column_and_wait_for_state(sensitive_data_model_id, create_sensitive_column_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.create_sensitive_column(sensitive_data_model_id, create_sensitive_column_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -1209,20 +1216,19 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#update_data_safe_private_endpoint} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#create_sensitive_data_model} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [String] data_safe_private_endpoint_id The OCID of the private endpoint.
-    # @param [OCI::DataSafe::Models::UpdateDataSafePrivateEndpointDetails] update_data_safe_private_endpoint_details The details used to update a Data Safe private endpoint.
+    # @param [OCI::DataSafe::Models::CreateSensitiveDataModelDetails] create_sensitive_data_model_details Details to create a new sensitive data model.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_data_safe_private_endpoint}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#create_sensitive_data_model}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def update_data_safe_private_endpoint_and_wait_for_state(data_safe_private_endpoint_id, update_data_safe_private_endpoint_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.update_data_safe_private_endpoint(data_safe_private_endpoint_id, update_data_safe_private_endpoint_details, base_operation_opts)
+    def create_sensitive_data_model_and_wait_for_state(create_sensitive_data_model_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.create_sensitive_data_model(create_sensitive_data_model_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -1259,20 +1265,19 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#update_on_prem_connector} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#create_sensitive_type} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [String] on_prem_connector_id The OCID of the on-premises connector.
-    # @param [OCI::DataSafe::Models::UpdateOnPremConnectorDetails] update_on_prem_connector_details The details used to update a on-premises connector.
+    # @param [OCI::DataSafe::Models::CreateSensitiveTypeDetails] create_sensitive_type_details Details to create a new sensitive type.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_on_prem_connector}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#create_sensitive_type}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def update_on_prem_connector_and_wait_for_state(on_prem_connector_id, update_on_prem_connector_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.update_on_prem_connector(on_prem_connector_id, update_on_prem_connector_details, base_operation_opts)
+    def create_sensitive_type_and_wait_for_state(create_sensitive_type_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.create_sensitive_type(create_sensitive_type_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -1309,20 +1314,19 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#update_on_prem_connector_wallet} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#create_target_alert_policy_association} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [OCI::DataSafe::Models::UpdateOnPremConnectorWalletDetails] update_on_prem_connector_wallet_details The details used to update an on-premises connector's wallet.
-    # @param [String] on_prem_connector_id The OCID of the on-premises connector.
+    # @param [OCI::DataSafe::Models::CreateTargetAlertPolicyAssociationDetails] create_target_alert_policy_association_details The details used to create a new target-alert policy association.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_on_prem_connector_wallet}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#create_target_alert_policy_association}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def update_on_prem_connector_wallet_and_wait_for_state(update_on_prem_connector_wallet_details, on_prem_connector_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.update_on_prem_connector_wallet(update_on_prem_connector_wallet_details, on_prem_connector_id, base_operation_opts)
+    def create_target_alert_policy_association_and_wait_for_state(create_target_alert_policy_association_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.create_target_alert_policy_association(create_target_alert_policy_association_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -1359,20 +1363,19 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#update_security_assessment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#create_target_database} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [String] security_assessment_id The OCID of the security assessment.
-    # @param [OCI::DataSafe::Models::UpdateSecurityAssessmentDetails] update_security_assessment_details The information to be updated.
+    # @param [OCI::DataSafe::Models::CreateTargetDatabaseDetails] create_target_database_details Details of the target database.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_security_assessment}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#create_target_database}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def update_security_assessment_and_wait_for_state(security_assessment_id, update_security_assessment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.update_security_assessment(security_assessment_id, update_security_assessment_details, base_operation_opts)
+    def create_target_database_and_wait_for_state(create_target_database_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.create_target_database(create_target_database_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -1409,20 +1412,68 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#update_target_database} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#create_user_assessment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [OCI::DataSafe::Models::CreateUserAssessmentDetails] create_user_assessment_details The details used to create a new saved user assessment.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#create_user_assessment}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def create_user_assessment_and_wait_for_state(create_user_assessment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.create_user_assessment(create_user_assessment_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#deactivate_target_database} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
     # @param [String] target_database_id The OCID of the Data Safe target database.
-    # @param [OCI::DataSafe::Models::UpdateTargetDatabaseDetails] update_target_database_details Details used to update the target database in Data Safe.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_target_database}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#deactivate_target_database}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def update_target_database_and_wait_for_state(target_database_id, update_target_database_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.update_target_database(target_database_id, update_target_database_details, base_operation_opts)
+    def deactivate_target_database_and_wait_for_state(target_database_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.deactivate_target_database(target_database_id, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util
@@ -1459,20 +1510,2970 @@ module OCI
     # rubocop:disable Layout/EmptyLines
 
 
-    # Calls {OCI::DataSafe::DataSafeClient#update_user_assessment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # Calls {OCI::DataSafe::DataSafeClient#delete_audit_archive_retrieval} and then waits for the {OCI::DataSafe::Models::WorkRequest}
     # to enter the given state(s).
     #
-    # @param [String] user_assessment_id The OCID of the user assessment.
-    # @param [OCI::DataSafe::Models::UpdateUserAssessmentDetails] update_user_assessment_details The information to be updated.
+    # @param [String] audit_archive_retrieval_id OCID of the archive retrieval.
     # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
-    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_user_assessment}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#delete_audit_archive_retrieval}
     # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
     #   * max_interval_seconds: The maximum interval between queries, in seconds.
     #   * max_wait_seconds The maximum time to wait, in seconds
     #
     # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
-    def update_user_assessment_and_wait_for_state(user_assessment_id, update_user_assessment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
-      operation_result = @service_client.update_user_assessment(user_assessment_id, update_user_assessment_details, base_operation_opts)
+    def delete_audit_archive_retrieval_and_wait_for_state(audit_archive_retrieval_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.delete_audit_archive_retrieval(audit_archive_retrieval_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#delete_audit_trail} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] audit_trail_id The OCID of the audit trail.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#delete_audit_trail}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def delete_audit_trail_and_wait_for_state(audit_trail_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.delete_audit_trail(audit_trail_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#delete_data_safe_private_endpoint} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] data_safe_private_endpoint_id The OCID of the private endpoint.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#delete_data_safe_private_endpoint}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def delete_data_safe_private_endpoint_and_wait_for_state(data_safe_private_endpoint_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.delete_data_safe_private_endpoint(data_safe_private_endpoint_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#delete_discovery_job} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] discovery_job_id The OCID of the discovery job.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#delete_discovery_job}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def delete_discovery_job_and_wait_for_state(discovery_job_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.delete_discovery_job(discovery_job_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#delete_library_masking_format} and then waits for the {OCI::DataSafe::Models::LibraryMaskingFormat} acted upon
+    # to enter the given state(s).
+    #
+    # @param [String] library_masking_format_id The OCID of the library masking format.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::LibraryMaskingFormat#lifecycle_state}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#delete_library_masking_format}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object with data of type nil
+    def delete_library_masking_format_and_wait_for_state(library_masking_format_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      initial_get_result = @service_client.get_library_masking_format(library_masking_format_id)
+      operation_result = @service_client.delete_library_masking_format(library_masking_format_id, base_operation_opts)
+
+      return operation_result if wait_for_states.empty?
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+
+      begin
+        waiter_result = initial_get_result.wait_until(
+          eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
+          max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+          max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200,
+          succeed_on_not_found: true
+        )
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#delete_masking_policy} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] masking_policy_id The OCID of the masking policy.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#delete_masking_policy}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def delete_masking_policy_and_wait_for_state(masking_policy_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.delete_masking_policy(masking_policy_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#delete_on_prem_connector} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] on_prem_connector_id The OCID of the on-premises connector.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#delete_on_prem_connector}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def delete_on_prem_connector_and_wait_for_state(on_prem_connector_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.delete_on_prem_connector(on_prem_connector_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#delete_report_definition} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] report_definition_id Unique report definition identifier
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#delete_report_definition}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def delete_report_definition_and_wait_for_state(report_definition_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.delete_report_definition(report_definition_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#delete_security_assessment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] security_assessment_id The OCID of the security assessment.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#delete_security_assessment}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def delete_security_assessment_and_wait_for_state(security_assessment_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.delete_security_assessment(security_assessment_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#delete_sensitive_data_model} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] sensitive_data_model_id The OCID of the sensitive data model.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#delete_sensitive_data_model}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def delete_sensitive_data_model_and_wait_for_state(sensitive_data_model_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.delete_sensitive_data_model(sensitive_data_model_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#delete_sensitive_type} and then waits for the {OCI::DataSafe::Models::SensitiveType} acted upon
+    # to enter the given state(s).
+    #
+    # @param [String] sensitive_type_id The OCID of the sensitive type.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::SensitiveType#lifecycle_state}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#delete_sensitive_type}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object with data of type nil
+    def delete_sensitive_type_and_wait_for_state(sensitive_type_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      initial_get_result = @service_client.get_sensitive_type(sensitive_type_id)
+      operation_result = @service_client.delete_sensitive_type(sensitive_type_id, base_operation_opts)
+
+      return operation_result if wait_for_states.empty?
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+
+      begin
+        waiter_result = initial_get_result.wait_until(
+          eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
+          max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+          max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200,
+          succeed_on_not_found: true
+        )
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#delete_target_alert_policy_association} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] target_alert_policy_association_id The OCID of the target-alert policy association.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#delete_target_alert_policy_association}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def delete_target_alert_policy_association_and_wait_for_state(target_alert_policy_association_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.delete_target_alert_policy_association(target_alert_policy_association_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#delete_target_database} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] target_database_id The OCID of the Data Safe target database.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#delete_target_database}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def delete_target_database_and_wait_for_state(target_database_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.delete_target_database(target_database_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#delete_user_assessment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] user_assessment_id The OCID of the user assessment.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#delete_user_assessment}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def delete_user_assessment_and_wait_for_state(user_assessment_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.delete_user_assessment(user_assessment_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#discover_audit_trails} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] audit_profile_id The OCID of the audit.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#discover_audit_trails}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def discover_audit_trails_and_wait_for_state(audit_profile_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.discover_audit_trails(audit_profile_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#enable_data_safe_configuration} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [OCI::DataSafe::Models::EnableDataSafeConfigurationDetails] enable_data_safe_configuration_details The details used to enable Data Safe.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#enable_data_safe_configuration}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def enable_data_safe_configuration_and_wait_for_state(enable_data_safe_configuration_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.enable_data_safe_configuration(enable_data_safe_configuration_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#generate_discovery_report_for_download} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] sensitive_data_model_id The OCID of the sensitive data model.
+    # @param [OCI::DataSafe::Models::GenerateDiscoveryReportForDownloadDetails] generate_discovery_report_for_download_details Details to generate a downloadable discovery report.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#generate_discovery_report_for_download}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def generate_discovery_report_for_download_and_wait_for_state(sensitive_data_model_id, generate_discovery_report_for_download_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.generate_discovery_report_for_download(sensitive_data_model_id, generate_discovery_report_for_download_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#generate_masking_policy_for_download} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] masking_policy_id The OCID of the masking policy.
+    # @param [OCI::DataSafe::Models::GenerateMaskingPolicyForDownloadDetails] generate_masking_policy_for_download_details Details to generate a masking policy file.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#generate_masking_policy_for_download}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def generate_masking_policy_for_download_and_wait_for_state(masking_policy_id, generate_masking_policy_for_download_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.generate_masking_policy_for_download(masking_policy_id, generate_masking_policy_for_download_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#generate_masking_report_for_download} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] masking_policy_id The OCID of the masking policy.
+    # @param [OCI::DataSafe::Models::GenerateMaskingReportForDownloadDetails] generate_masking_report_for_download_details Details to generate a downloadable masking report.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#generate_masking_report_for_download}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def generate_masking_report_for_download_and_wait_for_state(masking_policy_id, generate_masking_report_for_download_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.generate_masking_report_for_download(masking_policy_id, generate_masking_report_for_download_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#generate_report} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] report_definition_id Unique report definition identifier
+    # @param [OCI::DataSafe::Models::GenerateReportDetails] generate_report_details Details for report generation. It contains details such as PDF/XLS and filter parameters like audit event time limits, number of rows and target databases etc
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#generate_report}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def generate_report_and_wait_for_state(report_definition_id, generate_report_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.generate_report(report_definition_id, generate_report_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#generate_security_assessment_report} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] security_assessment_id The OCID of the security assessment.
+    # @param [OCI::DataSafe::Models::GenerateSecurityAssessmentReportDetails] generate_security_assessment_report_details Details of the report.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#generate_security_assessment_report}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def generate_security_assessment_report_and_wait_for_state(security_assessment_id, generate_security_assessment_report_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.generate_security_assessment_report(security_assessment_id, generate_security_assessment_report_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#generate_sensitive_data_model_for_download} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] sensitive_data_model_id The OCID of the sensitive data model.
+    # @param [OCI::DataSafe::Models::GenerateSensitiveDataModelForDownloadDetails] generate_sensitive_data_model_for_download_details Details to generate a sensitive data model file.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#generate_sensitive_data_model_for_download}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def generate_sensitive_data_model_for_download_and_wait_for_state(sensitive_data_model_id, generate_sensitive_data_model_for_download_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.generate_sensitive_data_model_for_download(sensitive_data_model_id, generate_sensitive_data_model_for_download_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#generate_user_assessment_report} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] user_assessment_id The OCID of the user assessment.
+    # @param [OCI::DataSafe::Models::GenerateUserAssessmentReportDetails] generate_user_assessment_report_details Details of the report.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#generate_user_assessment_report}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def generate_user_assessment_report_and_wait_for_state(user_assessment_id, generate_user_assessment_report_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.generate_user_assessment_report(user_assessment_id, generate_user_assessment_report_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#mask_data} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] masking_policy_id The OCID of the masking policy.
+    # @param [OCI::DataSafe::Models::MaskDataDetails] mask_data_details Details to mask data.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#mask_data}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def mask_data_and_wait_for_state(masking_policy_id, mask_data_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.mask_data(masking_policy_id, mask_data_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#modify_global_settings} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [OCI::DataSafe::Models::ModifyGlobalSettingsDetails] modify_global_settings_details The details used to update global settings in Data Safe.
+    # @param [String] compartment_id The OCID of the compartment.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#modify_global_settings}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def modify_global_settings_and_wait_for_state(modify_global_settings_details, compartment_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.modify_global_settings(modify_global_settings_details, compartment_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#patch_alerts} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [OCI::DataSafe::Models::PatchAlertsDetails] patch_alerts_details Details to patch alerts.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#patch_alerts}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def patch_alerts_and_wait_for_state(patch_alerts_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.patch_alerts(patch_alerts_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#patch_discovery_job_results} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] discovery_job_id The OCID of the discovery job.
+    # @param [OCI::DataSafe::Models::PatchDiscoveryJobResultDetails] patch_discovery_job_result_details Details to patch discovery results.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#patch_discovery_job_results}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def patch_discovery_job_results_and_wait_for_state(discovery_job_id, patch_discovery_job_result_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.patch_discovery_job_results(discovery_job_id, patch_discovery_job_result_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#patch_masking_columns} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] masking_policy_id The OCID of the masking policy.
+    # @param [OCI::DataSafe::Models::PatchMaskingColumnsDetails] patch_masking_columns_details Details to patch masking columns.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#patch_masking_columns}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def patch_masking_columns_and_wait_for_state(masking_policy_id, patch_masking_columns_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.patch_masking_columns(masking_policy_id, patch_masking_columns_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#patch_sensitive_columns} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] sensitive_data_model_id The OCID of the sensitive data model.
+    # @param [OCI::DataSafe::Models::PatchSensitiveColumnDetails] patch_sensitive_column_details Details to patch sensitive columns.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#patch_sensitive_columns}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def patch_sensitive_columns_and_wait_for_state(sensitive_data_model_id, patch_sensitive_column_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.patch_sensitive_columns(sensitive_data_model_id, patch_sensitive_column_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#provision_audit_policy} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [OCI::DataSafe::Models::ProvisionAuditPolicyDetails] provision_audit_policy_details Details for provisioning the given policies on the source target database.
+    # @param [String] audit_policy_id Unique audit policy identifier.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#provision_audit_policy}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def provision_audit_policy_and_wait_for_state(provision_audit_policy_details, audit_policy_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.provision_audit_policy(provision_audit_policy_details, audit_policy_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#refresh_security_assessment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] security_assessment_id The OCID of the security assessment.
+    # @param [OCI::DataSafe::Models::RunSecurityAssessmentDetails] run_security_assessment_details Details to create an on-demand saved security assessment.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#refresh_security_assessment}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def refresh_security_assessment_and_wait_for_state(security_assessment_id, run_security_assessment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.refresh_security_assessment(security_assessment_id, run_security_assessment_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#refresh_user_assessment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] user_assessment_id The OCID of the user assessment.
+    # @param [OCI::DataSafe::Models::RunUserAssessmentDetails] run_user_assessment_details The details required to create an on-demand saved user assessment.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#refresh_user_assessment}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def refresh_user_assessment_and_wait_for_state(user_assessment_id, run_user_assessment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.refresh_user_assessment(user_assessment_id, run_user_assessment_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#resume_audit_trail} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] audit_trail_id The OCID of the audit trail.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#resume_audit_trail}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def resume_audit_trail_and_wait_for_state(audit_trail_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.resume_audit_trail(audit_trail_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#retrieve_audit_policies} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] audit_policy_id Unique audit policy identifier.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#retrieve_audit_policies}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def retrieve_audit_policies_and_wait_for_state(audit_policy_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.retrieve_audit_policies(audit_policy_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#set_security_assessment_baseline} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] security_assessment_id The OCID of the security assessment.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#set_security_assessment_baseline}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def set_security_assessment_baseline_and_wait_for_state(security_assessment_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.set_security_assessment_baseline(security_assessment_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#set_user_assessment_baseline} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] user_assessment_id The OCID of the user assessment.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#set_user_assessment_baseline}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def set_user_assessment_baseline_and_wait_for_state(user_assessment_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.set_user_assessment_baseline(user_assessment_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#start_audit_trail} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [OCI::DataSafe::Models::StartAuditTrailDetails] start_audit_trail_details Details for the starting audit.
+    # @param [String] audit_trail_id The OCID of the audit trail.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#start_audit_trail}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def start_audit_trail_and_wait_for_state(start_audit_trail_details, audit_trail_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.start_audit_trail(start_audit_trail_details, audit_trail_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#stop_audit_trail} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] audit_trail_id The OCID of the audit trail.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#stop_audit_trail}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def stop_audit_trail_and_wait_for_state(audit_trail_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.stop_audit_trail(audit_trail_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#unset_security_assessment_baseline} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] security_assessment_id The OCID of the security assessment.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#unset_security_assessment_baseline}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def unset_security_assessment_baseline_and_wait_for_state(security_assessment_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.unset_security_assessment_baseline(security_assessment_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#unset_user_assessment_baseline} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] user_assessment_id The OCID of the user assessment.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#unset_user_assessment_baseline}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def unset_user_assessment_baseline_and_wait_for_state(user_assessment_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.unset_user_assessment_baseline(user_assessment_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#update_alert} and then waits for the {OCI::DataSafe::Models::Alert} acted upon
+    # to enter the given state(s).
+    #
+    # @param [String] alert_id The OCID of alert.
+    # @param [OCI::DataSafe::Models::UpdateAlertDetails] update_alert_details The details used to update alert status.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::Alert#lifecycle_state}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_alert}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataSafe::Models::Alert}
+    def update_alert_and_wait_for_state(alert_id, update_alert_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.update_alert(alert_id, update_alert_details, base_operation_opts)
+
+      return operation_result if wait_for_states.empty?
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.data.id
+
+      begin
+        waiter_result = @service_client.get_alert(wait_for_resource_id).wait_until(
+          eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
+          max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+          max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+        )
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#update_audit_archive_retrieval} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] audit_archive_retrieval_id OCID of the archive retrieval.
+    # @param [OCI::DataSafe::Models::UpdateAuditArchiveRetrievalDetails] update_audit_archive_retrieval_details Details to update the audit archive retrieval.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_audit_archive_retrieval}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def update_audit_archive_retrieval_and_wait_for_state(audit_archive_retrieval_id, update_audit_archive_retrieval_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.update_audit_archive_retrieval(audit_archive_retrieval_id, update_audit_archive_retrieval_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#update_audit_policy} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] audit_policy_id Unique audit policy identifier.
+    # @param [OCI::DataSafe::Models::UpdateAuditPolicyDetails] update_audit_policy_details Details to update the audit policy.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_audit_policy}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def update_audit_policy_and_wait_for_state(audit_policy_id, update_audit_policy_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.update_audit_policy(audit_policy_id, update_audit_policy_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#update_audit_profile} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] audit_profile_id The OCID of the audit.
+    # @param [OCI::DataSafe::Models::UpdateAuditProfileDetails] update_audit_profile_details The information to be updated.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_audit_profile}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def update_audit_profile_and_wait_for_state(audit_profile_id, update_audit_profile_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.update_audit_profile(audit_profile_id, update_audit_profile_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#update_audit_trail} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] audit_trail_id The OCID of the audit trail.
+    # @param [OCI::DataSafe::Models::UpdateAuditTrailDetails] update_audit_trail_details The information to be updated.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_audit_trail}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def update_audit_trail_and_wait_for_state(audit_trail_id, update_audit_trail_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.update_audit_trail(audit_trail_id, update_audit_trail_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#update_data_safe_private_endpoint} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] data_safe_private_endpoint_id The OCID of the private endpoint.
+    # @param [OCI::DataSafe::Models::UpdateDataSafePrivateEndpointDetails] update_data_safe_private_endpoint_details The details used to update a Data Safe private endpoint.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_data_safe_private_endpoint}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def update_data_safe_private_endpoint_and_wait_for_state(data_safe_private_endpoint_id, update_data_safe_private_endpoint_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.update_data_safe_private_endpoint(data_safe_private_endpoint_id, update_data_safe_private_endpoint_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#update_library_masking_format} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] library_masking_format_id The OCID of the library masking format.
+    # @param [OCI::DataSafe::Models::UpdateLibraryMaskingFormatDetails] update_library_masking_format_details Details to update a library masking format.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_library_masking_format}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def update_library_masking_format_and_wait_for_state(library_masking_format_id, update_library_masking_format_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.update_library_masking_format(library_masking_format_id, update_library_masking_format_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#update_masking_column} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] masking_column_key The unique key that identifies the masking column. It's numeric and unique within a masking policy.
+    # @param [String] masking_policy_id The OCID of the masking policy.
+    # @param [OCI::DataSafe::Models::UpdateMaskingColumnDetails] update_masking_column_details Details to update a masking column.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_masking_column}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def update_masking_column_and_wait_for_state(masking_column_key, masking_policy_id, update_masking_column_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.update_masking_column(masking_column_key, masking_policy_id, update_masking_column_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#update_masking_policy} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] masking_policy_id The OCID of the masking policy.
+    # @param [OCI::DataSafe::Models::UpdateMaskingPolicyDetails] update_masking_policy_details Details to update a masking policy.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_masking_policy}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def update_masking_policy_and_wait_for_state(masking_policy_id, update_masking_policy_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.update_masking_policy(masking_policy_id, update_masking_policy_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#update_on_prem_connector} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] on_prem_connector_id The OCID of the on-premises connector.
+    # @param [OCI::DataSafe::Models::UpdateOnPremConnectorDetails] update_on_prem_connector_details The details used to update a on-premises connector.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_on_prem_connector}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def update_on_prem_connector_and_wait_for_state(on_prem_connector_id, update_on_prem_connector_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.update_on_prem_connector(on_prem_connector_id, update_on_prem_connector_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#update_on_prem_connector_wallet} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [OCI::DataSafe::Models::UpdateOnPremConnectorWalletDetails] update_on_prem_connector_wallet_details The details used to update an on-premises connector's wallet.
+    # @param [String] on_prem_connector_id The OCID of the on-premises connector.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_on_prem_connector_wallet}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def update_on_prem_connector_wallet_and_wait_for_state(update_on_prem_connector_wallet_details, on_prem_connector_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.update_on_prem_connector_wallet(update_on_prem_connector_wallet_details, on_prem_connector_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#update_report_definition} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] report_definition_id Unique report definition identifier
+    # @param [OCI::DataSafe::Models::UpdateReportDefinitionDetails] update_report_definition_details Details for the modified report definition.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_report_definition}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def update_report_definition_and_wait_for_state(report_definition_id, update_report_definition_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.update_report_definition(report_definition_id, update_report_definition_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#update_security_assessment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] security_assessment_id The OCID of the security assessment.
+    # @param [OCI::DataSafe::Models::UpdateSecurityAssessmentDetails] update_security_assessment_details The information to be updated.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_security_assessment}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def update_security_assessment_and_wait_for_state(security_assessment_id, update_security_assessment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.update_security_assessment(security_assessment_id, update_security_assessment_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#update_sensitive_column} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] sensitive_data_model_id The OCID of the sensitive data model.
+    # @param [String] sensitive_column_key The unique key that identifies the sensitive column. It's numeric and unique within a sensitive data model.
+    # @param [OCI::DataSafe::Models::UpdateSensitiveColumnDetails] update_sensitive_column_details Details to update a sensitive column.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_sensitive_column}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def update_sensitive_column_and_wait_for_state(sensitive_data_model_id, sensitive_column_key, update_sensitive_column_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.update_sensitive_column(sensitive_data_model_id, sensitive_column_key, update_sensitive_column_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#update_sensitive_data_model} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] sensitive_data_model_id The OCID of the sensitive data model.
+    # @param [OCI::DataSafe::Models::UpdateSensitiveDataModelDetails] update_sensitive_data_model_details Details to update a sensitive data model.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_sensitive_data_model}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def update_sensitive_data_model_and_wait_for_state(sensitive_data_model_id, update_sensitive_data_model_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.update_sensitive_data_model(sensitive_data_model_id, update_sensitive_data_model_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#update_sensitive_type} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] sensitive_type_id The OCID of the sensitive type.
+    # @param [OCI::DataSafe::Models::UpdateSensitiveTypeDetails] update_sensitive_type_details Details to update a sensitive type.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_sensitive_type}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def update_sensitive_type_and_wait_for_state(sensitive_type_id, update_sensitive_type_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.update_sensitive_type(sensitive_type_id, update_sensitive_type_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#update_target_alert_policy_association} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] target_alert_policy_association_id The OCID of the target-alert policy association.
+    # @param [OCI::DataSafe::Models::UpdateTargetAlertPolicyAssociationDetails] update_target_alert_policy_association_details The details used to update the target-alert policy association.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_target_alert_policy_association}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def update_target_alert_policy_association_and_wait_for_state(target_alert_policy_association_id, update_target_alert_policy_association_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.update_target_alert_policy_association(target_alert_policy_association_id, update_target_alert_policy_association_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#update_target_database} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] target_database_id The OCID of the Data Safe target database.
+    # @param [OCI::DataSafe::Models::UpdateTargetDatabaseDetails] update_target_database_details Details used to update the target database in Data Safe.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_target_database}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def update_target_database_and_wait_for_state(target_database_id, update_target_database_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.update_target_database(target_database_id, update_target_database_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#update_user_assessment} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] user_assessment_id The OCID of the user assessment.
+    # @param [OCI::DataSafe::Models::UpdateUserAssessmentDetails] update_user_assessment_details The information to be updated.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#update_user_assessment}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def update_user_assessment_and_wait_for_state(user_assessment_id, update_user_assessment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.update_user_assessment(user_assessment_id, update_user_assessment_details, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#upload_masking_policy} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String, IO] upload_masking_policy_details Details to upload a masking policy file.
+    # @param [String] masking_policy_id The OCID of the masking policy.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#upload_masking_policy}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def upload_masking_policy_and_wait_for_state(upload_masking_policy_details, masking_policy_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.upload_masking_policy(upload_masking_policy_details, masking_policy_id, base_operation_opts)
+      use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
+
+      return operation_result if wait_for_states.empty? && !use_util
+
+      lowered_wait_for_states = wait_for_states.map(&:downcase)
+      wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+      begin
+        if use_util
+          waiter_result = OCI::DataSafe::Util.wait_on_work_request(
+            @service_client,
+            wait_for_resource_id,
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        else
+          waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
+            eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
+            max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
+            max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
+          )
+        end
+        result_to_return = waiter_result
+
+        return result_to_return
+      rescue StandardError
+        raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:enable Layout/EmptyLines
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/ParameterLists, Metrics/PerceivedComplexity
+    # rubocop:disable Layout/EmptyLines
+
+
+    # Calls {OCI::DataSafe::DataSafeClient#upload_sensitive_data_model} and then waits for the {OCI::DataSafe::Models::WorkRequest}
+    # to enter the given state(s).
+    #
+    # @param [String] sensitive_data_model_id The OCID of the sensitive data model.
+    # @param [String, IO] upload_sensitive_data_model_details Details to upload a sensitive data model file.
+    # @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataSafe::Models::WorkRequest#status}
+    # @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataSafe::DataSafeClient#upload_sensitive_data_model}
+    # @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:
+    #   * max_interval_seconds: The maximum interval between queries, in seconds.
+    #   * max_wait_seconds The maximum time to wait, in seconds
+    #
+    # @return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataSafe::Models::WorkRequest}
+    def upload_sensitive_data_model_and_wait_for_state(sensitive_data_model_id, upload_sensitive_data_model_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
+      operation_result = @service_client.upload_sensitive_data_model(sensitive_data_model_id, upload_sensitive_data_model_details, base_operation_opts)
       use_util = OCI::DataSafe::Util.respond_to?(:wait_on_work_request)
 
       return operation_result if wait_for_states.empty? && !use_util