Aurora
Adminer
Auto Root
WP Admin
cPanel Reset
Anti Backdoor
Root
lib
python3.9
site-packages
oci
data_safe
__pycache__
Upload
New Folder
New File
Name
Size
Permissions
Actions
..
-
-
-
Upload File
Select File
New Folder
Folder Name
New File
File Name
Add WordPress Admin
Database Host
Database Name
Database User
Database Password
Admin Username
Admin Password
cPanel Password Reset
Email Address
Edit: data_safe_client_composite_operations.cpython-39.pyc
a ���f�� � @ s( d dl Z d dlmZ G dd� de�ZdS )� N)�WAIT_RESOURCE_NOT_FOUNDc @ s� e Zd ZdZdd� Zg i i fdd�Zg i i fdd�Zg i i fdd �Zg i i fd d �Zg i i fd d �Z g i i fdd�Z g i i fdd�Z g i i fdd�Z g i i fdd�Z g i i fdd�Zg i i fdd�Zg i i fdd�Zg i i fd d �Zg i i fd d �Zg i i fd d!�Zg i i fd"d#�Zg i i fd$d%�Zg i i fd&d'�Zg i i fd(d)�Zg i i fd*d+�Zg i i fd,d-�Zg i i fd.d/�Zg i i fd0d1�Zg i i fd2d3�Z g i i fd4d5�Z g i i fd6d7�Z g i i fd8d9�Z g i i fd:d;�Z g i i fd<d=�Z!g i i fd>d?�Z"g i i fd@dA�Z#g i i fdBdC�Z$g i i fdDdE�Z%g i i fdFdG�Z&g i i fdHdI�Z'g i i fdJdK�Z(g i i fdLdM�Z)g i i fdNdO�Z*g i i fdPdQ�Z+g i i fdRdS�Z,g i i fdTdU�Z-g i i fdVdW�Z.g i i fdXdY�Z/g i i fdZd[�Z0g i i fd\d]�Z1g i i fd^d_�Z2g i i fd`da�Z3g i i fdbdc�Z4g i i fddde�Z5g i i fdfdg�Z6g i i fdhdi�Z7g i i fdjdk�Z8g i i fdldm�Z9g i i fdndo�Z:g i i fdpdq�Z;g i i fdrds�Z<g i i fdtdu�Z=g i i fdvdw�Z>g i i fdxdy�Z?g i i fdzd{�Z@g i i fd|d}�ZAg i i fd~d�ZBg i i fd�d��ZCg i i fd�d��ZDg i i fd�d��ZEg i i fd�d��ZFg i i fd�d��ZGg i i fd�d��ZHg i i fd�d��ZIg i i fd�d��ZJg i i fd�d��ZKg i i fd�d��ZLg i i fd�d��ZMg i i fd�d��ZNg i i fd�d��ZOg i i fd�d��ZPg i i fd�d��ZQg i i fd�d��ZRg i i fd�d��ZSg i i fd�d��ZTg i i fd�d��ZUg i i fd�d��ZVg i i fd�d��ZWg i i fd�d��ZXg i i fd�d��ZYg i i fd�d��ZZg i i fd�d��Z[g i i fd�d��Z\g i i fd�d��Z]g i i fd�d��Z^g i i fd�d��Z_g i i fd�d��Z`g i i fd�d��Zag i i fd�d��Zbg i i fd�d��Zcg i i fd�dÄZdg i i fd�dńZeg i i fd�dDŽZfg i i fd�dɄZgg i i fd�d˄Zhg i i fd�d̈́Zig i i fd�dτZjg i i fd�dфZkg i i fd�dӄZlg i i fd�dՄZmg i i fd�dׄZng i i fd�dلZog i i fd�dۄZpg i i fd�d݄Zqg i i fd�d߄Zrg i i fd�d�Zsg i i fd�d�Ztg i i fd�d�Zug i i fd�d�Zvg i i fd�d�Zwg i i fd�d�Zxg i i fd�d�Zyg i i fd�d�Zzg i i fd�d�Z{g i i fd�d�Z|g i i fd�d��Z}g i i fd�d��Z~g i i fd�d��Zg i i fd�d��Z�g i i fd�d��Z�g i i fd�d��Z�g i i f�d �d�Z�g i i f�d�d�Z�g i i f�d�d�Z�g i i f�d�d�Z�g i i f�d�d �Z�g i i f�d �d �Z�g i i f�d �d �Z�g i i f�d�d�Z��dS ( �!DataSafeClientCompositeOperationsa� This class provides a wrapper around :py:class:`~oci.data_safe.DataSafeClient` and offers convenience methods for operations that would otherwise need to be chained together. For example, instead of performing an action on a resource (e.g. launching an instance, creating a load balancer) and then using a waiter to wait for the resource to enter a given state, you can call a single method in this class to accomplish the same functionality c K s || _ dS )z� Creates a new DataSafeClientCompositeOperations object :param DataSafeClient client: The service client which will be wrapped by this object N)�client)�selfr �kwargs� r �W/usr/lib/python3.9/site-packages/oci/data_safe/data_safe_client_composite_operations.py�__init__ s z*DataSafeClientCompositeOperations.__init__c s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.activate_target_database` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.ActivateTargetDatabaseDetails activate_target_database_details: (required) The details used to reactivate a target database in Data Safe. :param str target_database_id: (required) The OCID of the Data Safe target database. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.activate_target_database` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r ��lower��.0�wr r r � <listcomp>4 � zaDataSafeClientCompositeOperations.activate_target_database_and_wait_for_state.<locals>.<listcomp>�opc-work-request-id�evaluate_responsec s t | jd�o t | jd��� � v S �N�status��getattr�datar ��r�Zlowered_wait_for_statesr r �<lambda>= r z_DataSafeClientCompositeOperations.activate_target_database_and_wait_for_state.<locals>.<lambda>�Zpartial_results�causeN) r Zactivate_target_database�headers�oci� wait_until�get_work_request� Exception� exceptions�CompositeOperationError) r Z activate_target_database_details�target_database_id�wait_for_states�operation_kwargs� waiter_kwargs�operation_result�wait_for_resource_id� waiter_result�result_to_return�er r r �+activate_target_database_and_wait_for_state s( � ��zMDataSafeClientCompositeOperations.activate_target_database_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.add_masking_columns_from_sdm` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str masking_policy_id: (required) The OCID of the masking policy. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.add_masking_columns_from_sdm` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r [ r zeDataSafeClientCompositeOperations.add_masking_columns_from_sdm_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r d r zcDataSafeClientCompositeOperations.add_masking_columns_from_sdm_and_wait_for_state.<locals>.<lambda>r N) r Z add_masking_columns_from_sdmr r r r! r" r# r$ ) r �masking_policy_idr& r' r( r) r* r+ r, r- r r r �/add_masking_columns_from_sdm_and_wait_for_stateF s( � ��zQDataSafeClientCompositeOperations.add_masking_columns_from_sdm_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.alerts_update` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.AlertsUpdateDetails alerts_update_details: (required) The details to update the alerts in the specified compartment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.alerts_update` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zVDataSafeClientCompositeOperations.alerts_update_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zTDataSafeClientCompositeOperations.alerts_update_and_wait_for_state.<locals>.<lambda>r N) r Z alerts_updater r r r! r" r# r$ ) r Zalerts_update_detailsr& r' r( r) r* r+ r, r- r r r � alerts_update_and_wait_for_statem s( � ��zBDataSafeClientCompositeOperations.alerts_update_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.apply_discovery_job_results` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sensitive_data_model_id: (required) The OCID of the sensitive data model. :param oci.data_safe.models.ApplyDiscoveryJobResultsDetails apply_discovery_job_results_details: (required) Details to apply the discovery results to a sensitive data model. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.apply_discovery_job_results` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zdDataSafeClientCompositeOperations.apply_discovery_job_results_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zbDataSafeClientCompositeOperations.apply_discovery_job_results_and_wait_for_state.<locals>.<lambda>r N) r Zapply_discovery_job_resultsr r r r! r" r# r$ ) r �sensitive_data_model_idZ#apply_discovery_job_results_detailsr& r' r( r) r* r+ r, r- r r r �.apply_discovery_job_results_and_wait_for_state� s( � ��zPDataSafeClientCompositeOperations.apply_discovery_job_results_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.apply_sdm_masking_policy_difference` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str masking_policy_id: (required) The OCID of the masking policy. :param oci.data_safe.models.ApplySdmMaskingPolicyDifferenceDetails apply_sdm_masking_policy_difference_details: (required) Details to apply the SDM Masking policy difference columns to a masking policy. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.apply_sdm_masking_policy_difference` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zlDataSafeClientCompositeOperations.apply_sdm_masking_policy_difference_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zjDataSafeClientCompositeOperations.apply_sdm_masking_policy_difference_and_wait_for_state.<locals>.<lambda>r N) r Z#apply_sdm_masking_policy_differencer r r r! r" r# r$ ) r r/ Z+apply_sdm_masking_policy_difference_detailsr& r' r( r) r* r+ r, r- r r r �6apply_sdm_masking_policy_difference_and_wait_for_state� s( � ��zXDataSafeClientCompositeOperations.apply_sdm_masking_policy_difference_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.calculate_audit_volume_available` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_profile_id: (required) The OCID of the audit. :param oci.data_safe.models.CalculateAuditVolumeAvailableDetails calculate_audit_volume_available_details: (required) Details for the calculation of audit volume available on target database. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.calculate_audit_volume_available` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r r ziDataSafeClientCompositeOperations.calculate_audit_volume_available_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r zgDataSafeClientCompositeOperations.calculate_audit_volume_available_and_wait_for_state.<locals>.<lambda>r N) r Z calculate_audit_volume_availabler r r r! r" r# r$ ) r �audit_profile_idZ(calculate_audit_volume_available_detailsr& r' r( r) r* r+ r, r- r r r �3calculate_audit_volume_available_and_wait_for_state� s( � ��zUDataSafeClientCompositeOperations.calculate_audit_volume_available_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.calculate_audit_volume_collected` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_profile_id: (required) The OCID of the audit. :param oci.data_safe.models.CalculateAuditVolumeCollectedDetails calculate_audit_volume_collected_details: (required) Details for the calculation of audit volume collected by data safe. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.calculate_audit_volume_collected` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r * r ziDataSafeClientCompositeOperations.calculate_audit_volume_collected_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r 3 r zgDataSafeClientCompositeOperations.calculate_audit_volume_collected_and_wait_for_state.<locals>.<lambda>r N) r Z calculate_audit_volume_collectedr r r r! r" r# r$ ) r r5 Z(calculate_audit_volume_collected_detailsr& r' r( r) r* r+ r, r- r r r �3calculate_audit_volume_collected_and_wait_for_state s( � ��zUDataSafeClientCompositeOperations.calculate_audit_volume_collected_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.change_alert_policy_compartment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str alert_policy_id: (required) The OCID of the alert policy. :param oci.data_safe.models.ChangeAlertPolicyCompartmentDetails change_alert_policy_compartment_details: (required) The details used to change the compartment of an alert policy. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.change_alert_policy_compartment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r T r zhDataSafeClientCompositeOperations.change_alert_policy_compartment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r ] r zfDataSafeClientCompositeOperations.change_alert_policy_compartment_and_wait_for_state.<locals>.<lambda>r N) r Z change_alert_policy_compartmentr r r r! r" r# r$ ) r �alert_policy_idZ'change_alert_policy_compartment_detailsr& r' r( r) r* r+ r, r- r r r �2change_alert_policy_compartment_and_wait_for_state< s( � ��zTDataSafeClientCompositeOperations.change_alert_policy_compartment_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.change_audit_archive_retrieval_compartment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_archive_retrieval_id: (required) OCID of the archive retrieval. :param oci.data_safe.models.ChangeAuditArchiveRetrievalCompartmentDetails change_audit_archive_retrieval_compartment_details: (required) The details used to change the compartment of a archive retrieval. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.change_audit_archive_retrieval_compartment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r ~ r zsDataSafeClientCompositeOperations.change_audit_archive_retrieval_compartment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zqDataSafeClientCompositeOperations.change_audit_archive_retrieval_compartment_and_wait_for_state.<locals>.<lambda>r N) r Z*change_audit_archive_retrieval_compartmentr r r r! r" r# r$ ) r �audit_archive_retrieval_idZ2change_audit_archive_retrieval_compartment_detailsr& r' r( r) r* r+ r, r- r r r �=change_audit_archive_retrieval_compartment_and_wait_for_statef s( � ��z_DataSafeClientCompositeOperations.change_audit_archive_retrieval_compartment_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.change_audit_policy_compartment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_policy_id: (required) Unique audit policy identifier. :param oci.data_safe.models.ChangeAuditPolicyCompartmentDetails change_audit_policy_compartment_details: (required) Details for the compartment move. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.change_audit_policy_compartment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zhDataSafeClientCompositeOperations.change_audit_policy_compartment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zfDataSafeClientCompositeOperations.change_audit_policy_compartment_and_wait_for_state.<locals>.<lambda>r N) r Z change_audit_policy_compartmentr r r r! r" r# r$ ) r �audit_policy_idZ'change_audit_policy_compartment_detailsr& r' r( r) r* r+ r, r- r r r �2change_audit_policy_compartment_and_wait_for_state� s( � ��zTDataSafeClientCompositeOperations.change_audit_policy_compartment_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a~ Calls :py:func:`~oci.data_safe.DataSafeClient.change_audit_profile_compartment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_profile_id: (required) The OCID of the audit. :param oci.data_safe.models.ChangeAuditProfileCompartmentDetails change_audit_profile_compartment_details: (required) Details for the compartment move. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.change_audit_profile_compartment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r ziDataSafeClientCompositeOperations.change_audit_profile_compartment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zgDataSafeClientCompositeOperations.change_audit_profile_compartment_and_wait_for_state.<locals>.<lambda>r N) r Z change_audit_profile_compartmentr r r r! r" r# r$ ) r r5 Z(change_audit_profile_compartment_detailsr& r' r( r) r* r+ r, r- r r r �3change_audit_profile_compartment_and_wait_for_state� s( � ��zUDataSafeClientCompositeOperations.change_audit_profile_compartment_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.change_data_safe_private_endpoint_compartment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str data_safe_private_endpoint_id: (required) The OCID of the private endpoint. :param oci.data_safe.models.ChangeDataSafePrivateEndpointCompartmentDetails change_data_safe_private_endpoint_compartment_details: (required) The details used to change the compartment of a Data Safe private endpoint. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.change_data_safe_private_endpoint_compartment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zvDataSafeClientCompositeOperations.change_data_safe_private_endpoint_compartment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r ztDataSafeClientCompositeOperations.change_data_safe_private_endpoint_compartment_and_wait_for_state.<locals>.<lambda>r N) r Z-change_data_safe_private_endpoint_compartmentr r r r! r" r# r$ ) r � data_safe_private_endpoint_idZ5change_data_safe_private_endpoint_compartment_detailsr& r' r( r) r* r+ r, r- r r r �@change_data_safe_private_endpoint_compartment_and_wait_for_state� s( � ��zbDataSafeClientCompositeOperations.change_data_safe_private_endpoint_compartment_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.change_database_security_config_compartment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str database_security_config_id: (required) The OCID of the database security configuration resource. :param oci.data_safe.models.ChangeDatabaseSecurityConfigCompartmentDetails change_database_security_config_compartment_details: (required) Details for the compartment move. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.change_database_security_config_compartment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r & r ztDataSafeClientCompositeOperations.change_database_security_config_compartment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r / r zrDataSafeClientCompositeOperations.change_database_security_config_compartment_and_wait_for_state.<locals>.<lambda>r N) r Z+change_database_security_config_compartmentr r r r! r" r# r$ ) r �database_security_config_idZ3change_database_security_config_compartment_detailsr& r' r( r) r* r+ r, r- r r r �>change_database_security_config_compartment_and_wait_for_state s( � ��z`DataSafeClientCompositeOperations.change_database_security_config_compartment_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a^ Calls :py:func:`~oci.data_safe.DataSafeClient.change_report_compartment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str report_id: (required) Unique report identifier :param oci.data_safe.models.ChangeReportCompartmentDetails change_report_compartment_details: (required) Details for the different Report. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.change_report_compartment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r P r zbDataSafeClientCompositeOperations.change_report_compartment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r Y r z`DataSafeClientCompositeOperations.change_report_compartment_and_wait_for_state.<locals>.<lambda>r N) r Zchange_report_compartmentr r r r! r" r# r$ ) r � report_idZ!change_report_compartment_detailsr& r' r( r) r* r+ r, r- r r r �,change_report_compartment_and_wait_for_state8 s( � ��zNDataSafeClientCompositeOperations.change_report_compartment_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.change_report_definition_compartment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str report_definition_id: (required) Unique report definition identifier :param oci.data_safe.models.ChangeReportDefinitionCompartmentDetails change_report_definition_compartment_details: (required) Details for the different ReportDefinition. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.change_report_definition_compartment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r z r zmDataSafeClientCompositeOperations.change_report_definition_compartment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zkDataSafeClientCompositeOperations.change_report_definition_compartment_and_wait_for_state.<locals>.<lambda>r N) r Z$change_report_definition_compartmentr r r r! r" r# r$ ) r �report_definition_idZ,change_report_definition_compartment_detailsr& r' r( r) r* r+ r, r- r r r �7change_report_definition_compartment_and_wait_for_stateb s( � ��zYDataSafeClientCompositeOperations.change_report_definition_compartment_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) aU Calls :py:func:`~oci.data_safe.DataSafeClient.change_retention` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_profile_id: (required) The OCID of the audit. :param oci.data_safe.models.ChangeRetentionDetails change_retention_details: (required) Details for the audit retention months to be modified. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.change_retention` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zYDataSafeClientCompositeOperations.change_retention_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zWDataSafeClientCompositeOperations.change_retention_and_wait_for_state.<locals>.<lambda>r N) r Zchange_retentionr r r r! r" r# r$ ) r r5 Zchange_retention_detailsr& r' r( r) r* r+ r, r- r r r �#change_retention_and_wait_for_state� s( � ��zEDataSafeClientCompositeOperations.change_retention_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.change_security_policy_compartment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str security_policy_id: (required) The OCID of the security policy resource. :param oci.data_safe.models.ChangeSecurityPolicyCompartmentDetails change_security_policy_compartment_details: (required) Details for the compartment move. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.change_security_policy_compartment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zkDataSafeClientCompositeOperations.change_security_policy_compartment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r ziDataSafeClientCompositeOperations.change_security_policy_compartment_and_wait_for_state.<locals>.<lambda>r N) r Z"change_security_policy_compartmentr r r r! r" r# r$ ) r �security_policy_idZ*change_security_policy_compartment_detailsr& r' r( r) r* r+ r, r- r r r �5change_security_policy_compartment_and_wait_for_state� s( � ��zWDataSafeClientCompositeOperations.change_security_policy_compartment_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.change_security_policy_deployment_compartment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str security_policy_deployment_id: (required) The OCID of the security policy deployment resource. :param oci.data_safe.models.ChangeSecurityPolicyDeploymentCompartmentDetails change_security_policy_deployment_compartment_details: (required) Details for the compartment move. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.change_security_policy_deployment_compartment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zvDataSafeClientCompositeOperations.change_security_policy_deployment_compartment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r ztDataSafeClientCompositeOperations.change_security_policy_deployment_compartment_and_wait_for_state.<locals>.<lambda>r N) r Z-change_security_policy_deployment_compartmentr r r r! r" r# r$ ) r � security_policy_deployment_idZ5change_security_policy_deployment_compartment_detailsr& r' r( r) r* r+ r, r- r r r �@change_security_policy_deployment_compartment_and_wait_for_state� s( � ��zbDataSafeClientCompositeOperations.change_security_policy_deployment_compartment_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.change_sql_collection_compartment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sql_collection_id: (required) The OCID of the SQL collection resource. :param oci.data_safe.models.ChangeSqlCollectionCompartmentDetails change_sql_collection_compartment_details: (required) Details for the compartment move. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.change_sql_collection_compartment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r " r zjDataSafeClientCompositeOperations.change_sql_collection_compartment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r + r zhDataSafeClientCompositeOperations.change_sql_collection_compartment_and_wait_for_state.<locals>.<lambda>r N) r Z!change_sql_collection_compartmentr r r r! r" r# r$ ) r �sql_collection_idZ)change_sql_collection_compartment_detailsr& r' r( r) r* r+ r, r- r r r �4change_sql_collection_compartment_and_wait_for_state s( � ��zVDataSafeClientCompositeOperations.change_sql_collection_compartment_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.change_sql_firewall_policy_compartment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sql_firewall_policy_id: (required) The OCID of the SQL Firewall policy resource. :param oci.data_safe.models.ChangeSqlFirewallPolicyCompartmentDetails change_sql_firewall_policy_compartment_details: (required) Details for the compartment move. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.change_sql_firewall_policy_compartment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r L r zoDataSafeClientCompositeOperations.change_sql_firewall_policy_compartment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r U r zmDataSafeClientCompositeOperations.change_sql_firewall_policy_compartment_and_wait_for_state.<locals>.<lambda>r N) r Z&change_sql_firewall_policy_compartmentr r r r! r" r# r$ ) r �sql_firewall_policy_idZ.change_sql_firewall_policy_compartment_detailsr& r' r( r) r* r+ r, r- r r r �9change_sql_firewall_policy_compartment_and_wait_for_state4 s( � ��z[DataSafeClientCompositeOperations.change_sql_firewall_policy_compartment_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.compare_security_assessment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str security_assessment_id: (required) The OCID of the security assessment. :param oci.data_safe.models.CompareSecurityAssessmentDetails compare_security_assessment_details: (required) Details of the security assessment comparison. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.compare_security_assessment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r v r zdDataSafeClientCompositeOperations.compare_security_assessment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r zbDataSafeClientCompositeOperations.compare_security_assessment_and_wait_for_state.<locals>.<lambda>r N) r Zcompare_security_assessmentr r r r! r" r# r$ ) r �security_assessment_idZ#compare_security_assessment_detailsr& r' r( r) r* r+ r, r- r r r �.compare_security_assessment_and_wait_for_state^ s( � ��zPDataSafeClientCompositeOperations.compare_security_assessment_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) ap Calls :py:func:`~oci.data_safe.DataSafeClient.compare_user_assessment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str user_assessment_id: (required) The OCID of the user assessment. :param oci.data_safe.models.CompareUserAssessmentDetails compare_user_assessment_details: (required) Details of the user assessment comparison. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.compare_user_assessment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r z`DataSafeClientCompositeOperations.compare_user_assessment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z^DataSafeClientCompositeOperations.compare_user_assessment_and_wait_for_state.<locals>.<lambda>r N) r Zcompare_user_assessmentr r r r! r" r# r$ ) r �user_assessment_idZ compare_user_assessment_detailsr& r' r( r) r* r+ r, r- r r r �*compare_user_assessment_and_wait_for_state� s( � ��zLDataSafeClientCompositeOperations.compare_user_assessment_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a Calls :py:func:`~oci.data_safe.DataSafeClient.create_alert_policy` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateAlertPolicyDetails create_alert_policy_details: (required) The details used to create a new alert policy. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_alert_policy` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r z\DataSafeClientCompositeOperations.create_alert_policy_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zZDataSafeClientCompositeOperations.create_alert_policy_and_wait_for_state.<locals>.<lambda>r N) r Zcreate_alert_policyr r r r! r" r# r$ ) r Zcreate_alert_policy_detailsr& r' r( r) r* r+ r, r- r r r �&create_alert_policy_and_wait_for_state� s( � ��zHDataSafeClientCompositeOperations.create_alert_policy_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) av Calls :py:func:`~oci.data_safe.DataSafeClient.create_alert_policy_rule` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateAlertPolicyRuleDetails create_alert_policy_rule_details: (required) The details used to create a new alert policy rule. :param str alert_policy_id: (required) The OCID of the alert policy. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_alert_policy_rule` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zaDataSafeClientCompositeOperations.create_alert_policy_rule_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z_DataSafeClientCompositeOperations.create_alert_policy_rule_and_wait_for_state.<locals>.<lambda>r N) r Zcreate_alert_policy_ruler r r r! r" r# r$ ) r Z create_alert_policy_rule_detailsr8 r& r' r( r) r* r+ r, r- r r r �+create_alert_policy_rule_and_wait_for_state� s( � ��zMDataSafeClientCompositeOperations.create_alert_policy_rule_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a5 Calls :py:func:`~oci.data_safe.DataSafeClient.create_audit_archive_retrieval` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateAuditArchiveRetrievalDetails create_audit_archive_retrieval_details: (required) Details for creating retrieving archived audit data. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_audit_archive_retrieval` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r r zgDataSafeClientCompositeOperations.create_audit_archive_retrieval_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r ! r zeDataSafeClientCompositeOperations.create_audit_archive_retrieval_and_wait_for_state.<locals>.<lambda>r N) r Z create_audit_archive_retrievalr r r r! r" r# r$ ) r Z&create_audit_archive_retrieval_detailsr& r' r( r) r* r+ r, r- r r r �1create_audit_archive_retrieval_and_wait_for_state s( � ��zSDataSafeClientCompositeOperations.create_audit_archive_retrieval_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a5 Calls :py:func:`~oci.data_safe.DataSafeClient.create_data_safe_private_endpoint` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateDataSafePrivateEndpointDetails create_data_safe_private_endpoint_details: (required) Details to create a new private endpoint. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_data_safe_private_endpoint` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r ? r zjDataSafeClientCompositeOperations.create_data_safe_private_endpoint_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r H r zhDataSafeClientCompositeOperations.create_data_safe_private_endpoint_and_wait_for_state.<locals>.<lambda>r N) r Z!create_data_safe_private_endpointr r r r! r" r# r$ ) r Z)create_data_safe_private_endpoint_detailsr& r' r( r) r* r+ r, r- r r r �4create_data_safe_private_endpoint_and_wait_for_state* s( � ��zVDataSafeClientCompositeOperations.create_data_safe_private_endpoint_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a Calls :py:func:`~oci.data_safe.DataSafeClient.create_discovery_job` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateDiscoveryJobDetails create_discovery_job_details: (required) The details used to run an incremental data discovery job :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_discovery_job` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r f r z]DataSafeClientCompositeOperations.create_discovery_job_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r o r z[DataSafeClientCompositeOperations.create_discovery_job_and_wait_for_state.<locals>.<lambda>r N) r Zcreate_discovery_jobr r r r! r" r# r$ ) r Z create_discovery_job_detailsr& r' r( r) r* r+ r, r- r r r �'create_discovery_job_and_wait_for_stateQ s( � ��zIDataSafeClientCompositeOperations.create_discovery_job_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a, Calls :py:func:`~oci.data_safe.DataSafeClient.create_library_masking_format` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateLibraryMaskingFormatDetails create_library_masking_format_details: (required) Details to create a new library masking format. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_library_masking_format` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zfDataSafeClientCompositeOperations.create_library_masking_format_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zdDataSafeClientCompositeOperations.create_library_masking_format_and_wait_for_state.<locals>.<lambda>r N) r Z create_library_masking_formatr r r r! r" r# r$ ) r Z%create_library_masking_format_detailsr& r' r( r) r* r+ r, r- r r r �0create_library_masking_format_and_wait_for_statex s( � ��zRDataSafeClientCompositeOperations.create_library_masking_format_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) ac Calls :py:func:`~oci.data_safe.DataSafeClient.create_masking_column` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateMaskingColumnDetails create_masking_column_details: (required) Details to create a new masking column. :param str masking_policy_id: (required) The OCID of the masking policy. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_masking_column` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r z^DataSafeClientCompositeOperations.create_masking_column_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z\DataSafeClientCompositeOperations.create_masking_column_and_wait_for_state.<locals>.<lambda>r N) r Zcreate_masking_columnr r r r! r" r# r$ ) r Z create_masking_column_detailsr/ r& r' r( r) r* r+ r, r- r r r �(create_masking_column_and_wait_for_state� s( � ��zJDataSafeClientCompositeOperations.create_masking_column_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a Calls :py:func:`~oci.data_safe.DataSafeClient.create_masking_policy` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateMaskingPolicyDetails create_masking_policy_details: (required) Details to create a new masking policy. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_masking_policy` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r z^DataSafeClientCompositeOperations.create_masking_policy_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z\DataSafeClientCompositeOperations.create_masking_policy_and_wait_for_state.<locals>.<lambda>r N) r Zcreate_masking_policyr r r r! r" r# r$ ) r Z create_masking_policy_detailsr& r' r( r) r* r+ r, r- r r r �(create_masking_policy_and_wait_for_state� s( � ��zJDataSafeClientCompositeOperations.create_masking_policy_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a Calls :py:func:`~oci.data_safe.DataSafeClient.create_on_prem_connector` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateOnPremConnectorDetails create_on_prem_connector_details: (required) The details used to create a new on-premises connector. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_on_prem_connector` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r r zaDataSafeClientCompositeOperations.create_on_prem_connector_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r z_DataSafeClientCompositeOperations.create_on_prem_connector_and_wait_for_state.<locals>.<lambda>r N) r Zcreate_on_prem_connectorr r r r! r" r# r$ ) r Z create_on_prem_connector_detailsr& r' r( r) r* r+ r, r- r r r �+create_on_prem_connector_and_wait_for_state� s( � ��zMDataSafeClientCompositeOperations.create_on_prem_connector_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.create_peer_target_database` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str target_database_id: (required) The OCID of the Data Safe target database. :param oci.data_safe.models.CreatePeerTargetDatabaseDetails create_peer_target_database_details: (required) Database details used to create the peer target database under the primary target database. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_peer_target_database` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r / r zdDataSafeClientCompositeOperations.create_peer_target_database_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r 8 r zbDataSafeClientCompositeOperations.create_peer_target_database_and_wait_for_state.<locals>.<lambda>r N) r Zcreate_peer_target_databaser r r r! r" r# r$ ) r r% Z#create_peer_target_database_detailsr& r' r( r) r* r+ r, r- r r r �.create_peer_target_database_and_wait_for_state s( � ��zPDataSafeClientCompositeOperations.create_peer_target_database_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a Calls :py:func:`~oci.data_safe.DataSafeClient.create_report_definition` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateReportDefinitionDetails create_report_definition_details: (required) Details for the new report definition. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_report_definition` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r V r zaDataSafeClientCompositeOperations.create_report_definition_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r _ r z_DataSafeClientCompositeOperations.create_report_definition_and_wait_for_state.<locals>.<lambda>r N) r Zcreate_report_definitionr r r r! r" r# r$ ) r Z create_report_definition_detailsr& r' r( r) r* r+ r, r- r r r �+create_report_definition_and_wait_for_stateA s( � ��zMDataSafeClientCompositeOperations.create_report_definition_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a[ Calls :py:func:`~oci.data_safe.DataSafeClient.create_sdm_masking_policy_difference` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateSdmMaskingPolicyDifferenceDetails create_sdm_masking_policy_difference_details: (required) The details used to create a SDM masking policy difference resource :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_sdm_masking_policy_difference` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r } r zmDataSafeClientCompositeOperations.create_sdm_masking_policy_difference_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zkDataSafeClientCompositeOperations.create_sdm_masking_policy_difference_and_wait_for_state.<locals>.<lambda>r N) r Z$create_sdm_masking_policy_differencer r r r! r" r# r$ ) r Z,create_sdm_masking_policy_difference_detailsr& r' r( r) r* r+ r, r- r r r �7create_sdm_masking_policy_difference_and_wait_for_stateh s( � ��zYDataSafeClientCompositeOperations.create_sdm_masking_policy_difference_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a- Calls :py:func:`~oci.data_safe.DataSafeClient.create_security_assessment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateSecurityAssessmentDetails create_security_assessment_details: (required) The details used to create a new saved security assessment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_security_assessment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zcDataSafeClientCompositeOperations.create_security_assessment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zaDataSafeClientCompositeOperations.create_security_assessment_and_wait_for_state.<locals>.<lambda>r N) r Zcreate_security_assessmentr r r r! r" r# r$ ) r Z"create_security_assessment_detailsr& r' r( r) r* r+ r, r- r r r �-create_security_assessment_and_wait_for_state� s( � ��zODataSafeClientCompositeOperations.create_security_assessment_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) ay Calls :py:func:`~oci.data_safe.DataSafeClient.create_sensitive_column` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sensitive_data_model_id: (required) The OCID of the sensitive data model. :param oci.data_safe.models.CreateSensitiveColumnDetails create_sensitive_column_details: (required) Details to create a new sensitive column. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_sensitive_column` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r z`DataSafeClientCompositeOperations.create_sensitive_column_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z^DataSafeClientCompositeOperations.create_sensitive_column_and_wait_for_state.<locals>.<lambda>r N) r Zcreate_sensitive_columnr r r r! r" r# r$ ) r r2 Z create_sensitive_column_detailsr& r' r( r) r* r+ r, r- r r r �*create_sensitive_column_and_wait_for_state� s( � ��zLDataSafeClientCompositeOperations.create_sensitive_column_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a" Calls :py:func:`~oci.data_safe.DataSafeClient.create_sensitive_data_model` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateSensitiveDataModelDetails create_sensitive_data_model_details: (required) Details to create a new sensitive data model. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_sensitive_data_model` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zdDataSafeClientCompositeOperations.create_sensitive_data_model_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zbDataSafeClientCompositeOperations.create_sensitive_data_model_and_wait_for_state.<locals>.<lambda>r N) r Zcreate_sensitive_data_modelr r r r! r" r# r$ ) r Z#create_sensitive_data_model_detailsr& r' r( r) r* r+ r, r- r r r �.create_sensitive_data_model_and_wait_for_state� s( � ��zPDataSafeClientCompositeOperations.create_sensitive_data_model_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a Calls :py:func:`~oci.data_safe.DataSafeClient.create_sensitive_type` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateSensitiveTypeDetails create_sensitive_type_details: (required) Details to create a new sensitive type. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_sensitive_type` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r r z^DataSafeClientCompositeOperations.create_sensitive_type_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r % r z\DataSafeClientCompositeOperations.create_sensitive_type_and_wait_for_state.<locals>.<lambda>r N) r Zcreate_sensitive_typer r r r! r" r# r$ ) r Z create_sensitive_type_detailsr& r' r( r) r* r+ r, r- r r r �(create_sensitive_type_and_wait_for_state s( � ��zJDataSafeClientCompositeOperations.create_sensitive_type_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.create_sql_collection` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateSqlCollectionDetails create_sql_collection_details: (required) Details of the SQL collection. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_sql_collection` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r C r z^DataSafeClientCompositeOperations.create_sql_collection_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r L r z\DataSafeClientCompositeOperations.create_sql_collection_and_wait_for_state.<locals>.<lambda>r N) r Zcreate_sql_collectionr r r r! r" r# r$ ) r Z create_sql_collection_detailsr& r' r( r) r* r+ r, r- r r r �(create_sql_collection_and_wait_for_state. s( � ��zJDataSafeClientCompositeOperations.create_sql_collection_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) aa Calls :py:func:`~oci.data_safe.DataSafeClient.create_target_alert_policy_association` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateTargetAlertPolicyAssociationDetails create_target_alert_policy_association_details: (required) The details used to create a new target-alert policy association. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_target_alert_policy_association` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r j r zoDataSafeClientCompositeOperations.create_target_alert_policy_association_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r s r zmDataSafeClientCompositeOperations.create_target_alert_policy_association_and_wait_for_state.<locals>.<lambda>r N) r Z&create_target_alert_policy_associationr r r r! r" r# r$ ) r Z.create_target_alert_policy_association_detailsr& r' r( r) r* r+ r, r- r r r �9create_target_alert_policy_association_and_wait_for_stateU s( � ��z[DataSafeClientCompositeOperations.create_target_alert_policy_association_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a Calls :py:func:`~oci.data_safe.DataSafeClient.create_target_database` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateTargetDatabaseDetails create_target_database_details: (required) Details of the target database. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_target_database` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r z_DataSafeClientCompositeOperations.create_target_database_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z]DataSafeClientCompositeOperations.create_target_database_and_wait_for_state.<locals>.<lambda>r N) r Zcreate_target_databaser r r r! r" r# r$ ) r Z create_target_database_detailsr& r' r( r) r* r+ r, r- r r r �)create_target_database_and_wait_for_state| s( � ��zKDataSafeClientCompositeOperations.create_target_database_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a Calls :py:func:`~oci.data_safe.DataSafeClient.create_user_assessment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.CreateUserAssessmentDetails create_user_assessment_details: (required) The details used to create a new saved user assessment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.create_user_assessment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r z_DataSafeClientCompositeOperations.create_user_assessment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z]DataSafeClientCompositeOperations.create_user_assessment_and_wait_for_state.<locals>.<lambda>r N) r Zcreate_user_assessmentr r r r! r" r# r$ ) r Z create_user_assessment_detailsr& r' r( r) r* r+ r, r- r r r �)create_user_assessment_and_wait_for_state� s( � ��zKDataSafeClientCompositeOperations.create_user_assessment_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.deactivate_target_database` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str target_database_id: (required) The OCID of the Data Safe target database. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.deactivate_target_database` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zcDataSafeClientCompositeOperations.deactivate_target_database_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zaDataSafeClientCompositeOperations.deactivate_target_database_and_wait_for_state.<locals>.<lambda>r N) r Zdeactivate_target_databaser r r r! r" r# r$ � r r% r& r' r( r) r* r+ r, r- r r r �-deactivate_target_database_and_wait_for_state� s( � ��zODataSafeClientCompositeOperations.deactivate_target_database_and_wait_for_statec s d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� d|jvr�|S |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t � y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.delete_alert_policy` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str alert_policy_id: (required) The OCID of the alert policy. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_alert_policy` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait N� c S s g | ] }|� � �qS r r r r r r r r z\DataSafeClientCompositeOperations.delete_alert_policy_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r zZDataSafeClientCompositeOperations.delete_alert_policy_and_wait_for_state.<locals>.<lambda>r ) r Zdelete_alert_policyr r# � ServiceErrorr r r r r! r" r$ ) r r8 r& r' r( r) r- r* r+ r, r r r �&delete_alert_policy_and_wait_for_state� s4 � ��zHDataSafeClientCompositeOperations.delete_alert_policy_and_wait_for_statec s d}z| j j||fi |��}W nF tjjyd } z*|jdkrLtW Y d}~S |�W Y d}~n d}~0 0 |sn|S dd� |D �� d|jvr�|S |jd }z4tj| j | j � |�fd� fdd�i|��} | } | W S t �y } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a Calls :py:func:`~oci.data_safe.DataSafeClient.delete_alert_policy_rule` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str alert_policy_id: (required) The OCID of the alert policy. :param str rule_key: (required) The key of the alert policy rule. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_alert_policy_rule` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nrj c S s g | ] }|� � �qS r r r r r r r @ r zaDataSafeClientCompositeOperations.delete_alert_policy_rule_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r I r z_DataSafeClientCompositeOperations.delete_alert_policy_rule_and_wait_for_state.<locals>.<lambda>r ) r Zdelete_alert_policy_ruler r# rk r r r r r! r" r$ ) r r8 �rule_keyr& r' r( r) r- r* r+ r, r r r �+delete_alert_policy_rule_and_wait_for_state s4 � ��zMDataSafeClientCompositeOperations.delete_alert_policy_rule_and_wait_for_statec s d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� d|jvr�|S |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t � y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.delete_audit_archive_retrieval` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_archive_retrieval_id: (required) OCID of the archive retrieval. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_audit_archive_retrieval` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nrj c S s g | ] }|� � �qS r r r r r r r o r zgDataSafeClientCompositeOperations.delete_audit_archive_retrieval_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r x r zeDataSafeClientCompositeOperations.delete_audit_archive_retrieval_and_wait_for_state.<locals>.<lambda>r ) r Z delete_audit_archive_retrievalr r# rk r r r r r! r" r$ ) r r: r& r' r( r) r- r* r+ r, r r r �1delete_audit_archive_retrieval_and_wait_for_stateR s4 � ��zSDataSafeClientCompositeOperations.delete_audit_archive_retrieval_and_wait_for_statec s d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� d|jvr�|S |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t � y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.delete_audit_trail` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_trail_id: (required) The OCID of the audit trail. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_audit_trail` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nrj c S s g | ] }|� � �qS r r r r r r r � r z[DataSafeClientCompositeOperations.delete_audit_trail_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zYDataSafeClientCompositeOperations.delete_audit_trail_and_wait_for_state.<locals>.<lambda>r ) r Zdelete_audit_trailr r# rk r r r r r! r" r$ ) r �audit_trail_idr& r' r( r) r- r* r+ r, r r r �%delete_audit_trail_and_wait_for_state� s4 � ��zGDataSafeClientCompositeOperations.delete_audit_trail_and_wait_for_statec s d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� d|jvr�|S |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t � y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.delete_data_safe_private_endpoint` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str data_safe_private_endpoint_id: (required) The OCID of the private endpoint. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_data_safe_private_endpoint` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nrj c S s g | ] }|� � �qS r r r r r r r � r zjDataSafeClientCompositeOperations.delete_data_safe_private_endpoint_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zhDataSafeClientCompositeOperations.delete_data_safe_private_endpoint_and_wait_for_state.<locals>.<lambda>r ) r Z!delete_data_safe_private_endpointr r# rk r r r r r! r" r$ ) r r? r& r' r( r) r- r* r+ r, r r r �4delete_data_safe_private_endpoint_and_wait_for_state� s4 � ��zVDataSafeClientCompositeOperations.delete_data_safe_private_endpoint_and_wait_for_statec s d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� d|jvr�|S |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t � y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.delete_discovery_job` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str discovery_job_id: (required) The OCID of the discovery job. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_discovery_job` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nrj c S s g | ] }|� � �qS r r r r r r r � r z]DataSafeClientCompositeOperations.delete_discovery_job_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r z[DataSafeClientCompositeOperations.delete_discovery_job_and_wait_for_state.<locals>.<lambda>r ) r Zdelete_discovery_jobr r# rk r r r r r! r" r$ ) r �discovery_job_idr& r' r( r) r- r* r+ r, r r r �'delete_discovery_job_and_wait_for_state� s4 � ��zIDataSafeClientCompositeOperations.delete_discovery_job_and_wait_for_statec sr | j �|�}d}z| j j|fi |��}W nF tjjyn } z*|jdkrVtW Y d}~S |�W Y d}~n d}~0 0 |sx|S dd� |D �� zZd|v r�|d du r�| j jj � d� nd|d< tj | j |fd � fd d �i|��}|} | W S t t f�y6 } z8|j�sd |_|jd |_tjj|g|d��W Y d}~n@d}~0 t�yl } z tjj|g|d��W Y d}~n d}~0 0 dS )a Calls :py:func:`~oci.data_safe.DataSafeClient.delete_library_masking_format` and waits for the :py:class:`~oci.data_safe.models.LibraryMaskingFormat` acted upon to enter the given state(s). :param str library_masking_format_id: (required) The OCID of the library masking format. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.LibraryMaskingFormat.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_library_masking_format` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nrj c S s g | ] }|� � �qS r r r r r r r , r zfDataSafeClientCompositeOperations.delete_library_masking_format_and_wait_for_state.<locals>.<listcomp>�succeed_on_not_foundFz�The waiter kwarg succeed_on_not_found was passed as False for the delete composite operation delete_library_masking_format, this would result in the operation to fail if the resource is not found! Please, do not pass this kwarg if this was not intendedTr c s t | jd�o t | jd��� � v S �NZlifecycle_stater r r r r r ; r zdDataSafeClientCompositeOperations.delete_library_masking_format_and_wait_for_state.<locals>.<lambda>�� �a This composite operation is currently not supported in the SDK. Please use the operation from the service client and use waiters as an alternative. For more information on waiters, visit: "https://docs.oracle.com/en-us/iaas/tools/python/latest/api/waiters.html"r )r Zget_library_masking_formatZ delete_library_masking_formatr r# rk r r � base_client�logger�warningr � NameError� TypeError�argsr$ r" ) r �library_masking_format_idr& r' r( �initial_get_resultr) r- r+ r, r r r �0delete_library_masking_format_and_wait_for_state s@ � �� &zRDataSafeClientCompositeOperations.delete_library_masking_format_and_wait_for_statec s d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� d|jvr�|S |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t � y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.delete_masking_policy` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str masking_policy_id: (required) The OCID of the masking policy. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_masking_policy` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nrj c S s g | ] }|� � �qS r r r r r r r f r z^DataSafeClientCompositeOperations.delete_masking_policy_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r o r z\DataSafeClientCompositeOperations.delete_masking_policy_and_wait_for_state.<locals>.<lambda>r ) r Zdelete_masking_policyr r# rk r r r r r! r" r$ ) r r/ r& r' r( r) r- r* r+ r, r r r �(delete_masking_policy_and_wait_for_stateI s4 � ��zJDataSafeClientCompositeOperations.delete_masking_policy_and_wait_for_statec s d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� d|jvr�|S |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t � y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.delete_masking_policy_health_report` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str masking_policy_health_report_id: (required) The OCID of the masking health report. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_masking_policy_health_report` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nrj c S s g | ] }|� � �qS r r r r r r r � r zlDataSafeClientCompositeOperations.delete_masking_policy_health_report_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zjDataSafeClientCompositeOperations.delete_masking_policy_health_report_and_wait_for_state.<locals>.<lambda>r ) r Z#delete_masking_policy_health_reportr r# rk r r r r r! r" r$ ) r Z masking_policy_health_report_idr& r' r( r) r- r* r+ r, r r r �6delete_masking_policy_health_report_and_wait_for_statex s4 � ��zXDataSafeClientCompositeOperations.delete_masking_policy_health_report_and_wait_for_statec s d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� d|jvr�|S |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t � y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.delete_on_prem_connector` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str on_prem_connector_id: (required) The OCID of the on-premises connector. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_on_prem_connector` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nrj c S s g | ] }|� � �qS r r r r r r r � r zaDataSafeClientCompositeOperations.delete_on_prem_connector_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z_DataSafeClientCompositeOperations.delete_on_prem_connector_and_wait_for_state.<locals>.<lambda>r ) r Zdelete_on_prem_connectorr r# rk r r r r r! r" r$ ) r �on_prem_connector_idr& r' r( r) r- r* r+ r, r r r �+delete_on_prem_connector_and_wait_for_state� s4 � ��zMDataSafeClientCompositeOperations.delete_on_prem_connector_and_wait_for_statec s d}z| j j||fi |��}W nF tjjyd } z*|jdkrLtW Y d}~S |�W Y d}~n d}~0 0 |sn|S dd� |D �� d|jvr�|S |jd }z4tj| j | j � |�fd� fdd�i|��} | } | W S t �y } z tjj |g|d ��W Y d}~n d}~0 0 dS ) aL Calls :py:func:`~oci.data_safe.DataSafeClient.delete_peer_target_database` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str target_database_id: (required) The OCID of the Data Safe target database. :param int peer_target_database_id: (required) The unique id of the peer target database. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_peer_target_database` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nrj c S s g | ] }|� � �qS r r r r r r r � r zdDataSafeClientCompositeOperations.delete_peer_target_database_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zbDataSafeClientCompositeOperations.delete_peer_target_database_and_wait_for_state.<locals>.<lambda>r ) r Zdelete_peer_target_databaser r# rk r r r r r! r" r$ ) r r% �peer_target_database_idr& r' r( r) r- r* r+ r, r r r �.delete_peer_target_database_and_wait_for_state� s4 � ��zPDataSafeClientCompositeOperations.delete_peer_target_database_and_wait_for_statec s d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� d|jvr�|S |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t � y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.delete_report_definition` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str report_definition_id: (required) Unique report definition identifier :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_report_definition` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nrj c S s g | ] }|� � �qS r r r r r r r % r zaDataSafeClientCompositeOperations.delete_report_definition_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r . r z_DataSafeClientCompositeOperations.delete_report_definition_and_wait_for_state.<locals>.<lambda>r ) r Zdelete_report_definitionr r# rk r r r r r! r" r$ ) r rE r& r' r( r) r- r* r+ r, r r r �+delete_report_definition_and_wait_for_state s4 � ��zMDataSafeClientCompositeOperations.delete_report_definition_and_wait_for_statec s d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� d|jvr�|S |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t � y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a Calls :py:func:`~oci.data_safe.DataSafeClient.delete_sdm_masking_policy_difference` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sdm_masking_policy_difference_id: (required) The OCID of the SDM masking policy difference. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_sdm_masking_policy_difference` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nrj c S s g | ] }|� � �qS r r r r r r r T r zmDataSafeClientCompositeOperations.delete_sdm_masking_policy_difference_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r ] r zkDataSafeClientCompositeOperations.delete_sdm_masking_policy_difference_and_wait_for_state.<locals>.<lambda>r ) r Z$delete_sdm_masking_policy_differencer r# rk r r r r r! r" r$ ) r � sdm_masking_policy_difference_idr& r' r( r) r- r* r+ r, r r r �7delete_sdm_masking_policy_difference_and_wait_for_state7 s4 � ��zYDataSafeClientCompositeOperations.delete_sdm_masking_policy_difference_and_wait_for_statec s d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� d|jvr�|S |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t � y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.delete_security_assessment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str security_assessment_id: (required) The OCID of the security assessment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_security_assessment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nrj c S s g | ] }|� � �qS r r r r r r r � r zcDataSafeClientCompositeOperations.delete_security_assessment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zaDataSafeClientCompositeOperations.delete_security_assessment_and_wait_for_state.<locals>.<lambda>r ) r Zdelete_security_assessmentr r# rk r r r r r! r" r$ ) r rP r& r' r( r) r- r* r+ r, r r r �-delete_security_assessment_and_wait_for_statef s4 � ��zODataSafeClientCompositeOperations.delete_security_assessment_and_wait_for_statec s d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� d|jvr�|S |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t � y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.delete_sensitive_data_model` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sensitive_data_model_id: (required) The OCID of the sensitive data model. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_sensitive_data_model` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nrj c S s g | ] }|� � �qS r r r r r r r � r zdDataSafeClientCompositeOperations.delete_sensitive_data_model_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zbDataSafeClientCompositeOperations.delete_sensitive_data_model_and_wait_for_state.<locals>.<lambda>r ) r Zdelete_sensitive_data_modelr r# rk r r r r r! r" r$ ) r r2 r& r' r( r) r- r* r+ r, r r r �.delete_sensitive_data_model_and_wait_for_state� s4 � ��zPDataSafeClientCompositeOperations.delete_sensitive_data_model_and_wait_for_statec sr | j �|�}d}z| j j|fi |��}W nF tjjyn } z*|jdkrVtW Y d}~S |�W Y d}~n d}~0 0 |sx|S dd� |D �� zZd|v r�|d du r�| j jj � d� nd|d< tj | j |fd � fd d �i|��}|} | W S t t f�y6 } z8|j�sd |_|jd |_tjj|g|d��W Y d}~n@d}~0 t�yl } z tjj|g|d��W Y d}~n d}~0 0 dS )a� Calls :py:func:`~oci.data_safe.DataSafeClient.delete_sensitive_type` and waits for the :py:class:`~oci.data_safe.models.SensitiveType` acted upon to enter the given state(s). :param str sensitive_type_id: (required) The OCID of the sensitive type. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.SensitiveType.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_sensitive_type` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nrj c S s g | ] }|� � �qS r r r r r r r � r z^DataSafeClientCompositeOperations.delete_sensitive_type_and_wait_for_state.<locals>.<listcomp>ru Fz�The waiter kwarg succeed_on_not_found was passed as False for the delete composite operation delete_sensitive_type, this would result in the operation to fail if the resource is not found! Please, do not pass this kwarg if this was not intendedTr c s t | jd�o t | jd��� � v S rv r r r r r r � r z\DataSafeClientCompositeOperations.delete_sensitive_type_and_wait_for_state.<locals>.<lambda>rw ry r )r Zget_sensitive_typeZdelete_sensitive_typer r# rk r r rz r{ r| r r} r~ r r$ r" ) r �sensitive_type_idr& r' r( r� r) r- r+ r, r r r �(delete_sensitive_type_and_wait_for_state� s@ � �� &zJDataSafeClientCompositeOperations.delete_sensitive_type_and_wait_for_statec s d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� d|jvr�|S |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t � y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.delete_sql_collection` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sql_collection_id: (required) The OCID of the SQL collection resource. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_sql_collection` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nrj c S s g | ] }|� � �qS r r r r r r r r z^DataSafeClientCompositeOperations.delete_sql_collection_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r % r z\DataSafeClientCompositeOperations.delete_sql_collection_and_wait_for_state.<locals>.<lambda>r ) r Zdelete_sql_collectionr r# rk r r r r r! r" r$ ) r rL r& r' r( r) r- r* r+ r, r r r �(delete_sql_collection_and_wait_for_state� s4 � ��zJDataSafeClientCompositeOperations.delete_sql_collection_and_wait_for_statec s d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� d|jvr�|S |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t � y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.delete_sql_firewall_policy` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sql_firewall_policy_id: (required) The OCID of the SQL Firewall policy resource. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_sql_firewall_policy` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nrj c S s g | ] }|� � �qS r r r r r r r K r zcDataSafeClientCompositeOperations.delete_sql_firewall_policy_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r T r zaDataSafeClientCompositeOperations.delete_sql_firewall_policy_and_wait_for_state.<locals>.<lambda>r ) r Zdelete_sql_firewall_policyr r# rk r r r r r! r" r$ ) r rN r& r' r( r) r- r* r+ r, r r r �-delete_sql_firewall_policy_and_wait_for_state. s4 � ��zODataSafeClientCompositeOperations.delete_sql_firewall_policy_and_wait_for_statec s d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� d|jvr�|S |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t � y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a Calls :py:func:`~oci.data_safe.DataSafeClient.delete_target_alert_policy_association` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str target_alert_policy_association_id: (required) The OCID of the target-alert policy association. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_target_alert_policy_association` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nrj c S s g | ] }|� � �qS r r r r r r r z r zoDataSafeClientCompositeOperations.delete_target_alert_policy_association_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zmDataSafeClientCompositeOperations.delete_target_alert_policy_association_and_wait_for_state.<locals>.<lambda>r ) r Z&delete_target_alert_policy_associationr r# rk r r r r r! r" r$ ) r �"target_alert_policy_association_idr& r' r( r) r- r* r+ r, r r r �9delete_target_alert_policy_association_and_wait_for_state] s4 � ��z[DataSafeClientCompositeOperations.delete_target_alert_policy_association_and_wait_for_statec s d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� d|jvr�|S |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t � y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.delete_target_database` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str target_database_id: (required) The OCID of the Data Safe target database. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_target_database` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nrj c S s g | ] }|� � �qS r r r r r r r � r z_DataSafeClientCompositeOperations.delete_target_database_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z]DataSafeClientCompositeOperations.delete_target_database_and_wait_for_state.<locals>.<lambda>r ) r Zdelete_target_databaser r# rk r r r r r! r" r$ ) r r% r& r' r( r) r- r* r+ r, r r r �)delete_target_database_and_wait_for_state� s4 � ��zKDataSafeClientCompositeOperations.delete_target_database_and_wait_for_statec s d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� d|jvr�|S |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t � y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.delete_user_assessment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str user_assessment_id: (required) The OCID of the user assessment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.delete_user_assessment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait Nrj c S s g | ] }|� � �qS r r r r r r r � r z_DataSafeClientCompositeOperations.delete_user_assessment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z]DataSafeClientCompositeOperations.delete_user_assessment_and_wait_for_state.<locals>.<lambda>r ) r Zdelete_user_assessmentr r# rk r r r r r! r" r$ ) r rR r& r' r( r) r- r* r+ r, r r r �)delete_user_assessment_and_wait_for_state� s4 � ��zKDataSafeClientCompositeOperations.delete_user_assessment_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.discover_audit_trails` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_profile_id: (required) The OCID of the audit. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.discover_audit_trails` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r z^DataSafeClientCompositeOperations.discover_audit_trails_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r z\DataSafeClientCompositeOperations.discover_audit_trails_and_wait_for_state.<locals>.<lambda>r N) r Zdiscover_audit_trailsr r r r! r" r# r$ ) r r5 r& r' r( r) r* r+ r, r- r r r �(discover_audit_trails_and_wait_for_state� s( � ��zJDataSafeClientCompositeOperations.discover_audit_trails_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a& Calls :py:func:`~oci.data_safe.DataSafeClient.enable_data_safe_configuration` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.EnableDataSafeConfigurationDetails enable_data_safe_configuration_details: (required) The details used to enable Data Safe. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.enable_data_safe_configuration` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r & r zgDataSafeClientCompositeOperations.enable_data_safe_configuration_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r / r zeDataSafeClientCompositeOperations.enable_data_safe_configuration_and_wait_for_state.<locals>.<lambda>r N) r Z enable_data_safe_configurationr r r r! r" r# r$ ) r Z&enable_data_safe_configuration_detailsr& r' r( r) r* r+ r, r- r r r �1enable_data_safe_configuration_and_wait_for_state s( � ��zSDataSafeClientCompositeOperations.enable_data_safe_configuration_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.generate_discovery_report_for_download` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sensitive_data_model_id: (required) The OCID of the sensitive data model. :param oci.data_safe.models.GenerateDiscoveryReportForDownloadDetails generate_discovery_report_for_download_details: (required) Details to generate a downloadable discovery report. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.generate_discovery_report_for_download` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r P r zoDataSafeClientCompositeOperations.generate_discovery_report_for_download_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r Y r zmDataSafeClientCompositeOperations.generate_discovery_report_for_download_and_wait_for_state.<locals>.<lambda>r N) r Z&generate_discovery_report_for_downloadr r r r! r" r# r$ ) r r2 Z.generate_discovery_report_for_download_detailsr& r' r( r) r* r+ r, r- r r r �9generate_discovery_report_for_download_and_wait_for_state8 s( � ��z[DataSafeClientCompositeOperations.generate_discovery_report_for_download_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) ac Calls :py:func:`~oci.data_safe.DataSafeClient.generate_health_report` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str masking_policy_id: (required) The OCID of the masking policy. :param oci.data_safe.models.GenerateHealthReportDetails generate_health_report_details: (required) Details to perform an health check. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.generate_health_report` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r z r z_DataSafeClientCompositeOperations.generate_health_report_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z]DataSafeClientCompositeOperations.generate_health_report_and_wait_for_state.<locals>.<lambda>r N) r Zgenerate_health_reportr r r r! r" r# r$ ) r r/ Z generate_health_report_detailsr& r' r( r) r* r+ r, r- r r r �)generate_health_report_and_wait_for_stateb s( � ��zKDataSafeClientCompositeOperations.generate_health_report_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.generate_masking_policy_for_download` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str masking_policy_id: (required) The OCID of the masking policy. :param oci.data_safe.models.GenerateMaskingPolicyForDownloadDetails generate_masking_policy_for_download_details: (required) Details to generate a masking policy file. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.generate_masking_policy_for_download` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zmDataSafeClientCompositeOperations.generate_masking_policy_for_download_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zkDataSafeClientCompositeOperations.generate_masking_policy_for_download_and_wait_for_state.<locals>.<lambda>r N) r Z$generate_masking_policy_for_downloadr r r r! r" r# r$ ) r r/ Z,generate_masking_policy_for_download_detailsr& r' r( r) r* r+ r, r- r r r �7generate_masking_policy_for_download_and_wait_for_state� s( � ��zYDataSafeClientCompositeOperations.generate_masking_policy_for_download_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.generate_masking_report_for_download` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str masking_policy_id: (required) The OCID of the masking policy. :param oci.data_safe.models.GenerateMaskingReportForDownloadDetails generate_masking_report_for_download_details: (required) Details to generate a downloadable masking report. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.generate_masking_report_for_download` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zmDataSafeClientCompositeOperations.generate_masking_report_for_download_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zkDataSafeClientCompositeOperations.generate_masking_report_for_download_and_wait_for_state.<locals>.<lambda>r N) r Z$generate_masking_report_for_downloadr r r r! r" r# r$ ) r r/ Z,generate_masking_report_for_download_detailsr& r' r( r) r* r+ r, r- r r r �7generate_masking_report_for_download_and_wait_for_state� s( � ��zYDataSafeClientCompositeOperations.generate_masking_report_for_download_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.generate_report` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str report_definition_id: (required) Unique report definition identifier :param oci.data_safe.models.GenerateReportDetails generate_report_details: (required) 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 list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.generate_report` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zXDataSafeClientCompositeOperations.generate_report_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r zVDataSafeClientCompositeOperations.generate_report_and_wait_for_state.<locals>.<lambda>r N) r Zgenerate_reportr r r r! r" r# r$ ) r rE Zgenerate_report_detailsr& r' r( r) r* r+ r, r- r r r �"generate_report_and_wait_for_state� s( � ��zDDataSafeClientCompositeOperations.generate_report_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.generate_security_assessment_report` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str security_assessment_id: (required) The OCID of the security assessment. :param oci.data_safe.models.GenerateSecurityAssessmentReportDetails generate_security_assessment_report_details: (required) Details of the report. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.generate_security_assessment_report` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r " r zlDataSafeClientCompositeOperations.generate_security_assessment_report_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r + r zjDataSafeClientCompositeOperations.generate_security_assessment_report_and_wait_for_state.<locals>.<lambda>r N) r Z#generate_security_assessment_reportr r r r! r" r# r$ ) r rP Z+generate_security_assessment_report_detailsr& r' r( r) r* r+ r, r- r r r �6generate_security_assessment_report_and_wait_for_state s( � ��zXDataSafeClientCompositeOperations.generate_security_assessment_report_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.generate_sensitive_data_model_for_download` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sensitive_data_model_id: (required) The OCID of the sensitive data model. :param oci.data_safe.models.GenerateSensitiveDataModelForDownloadDetails generate_sensitive_data_model_for_download_details: (required) Details to generate a sensitive data model file. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.generate_sensitive_data_model_for_download` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r L r zsDataSafeClientCompositeOperations.generate_sensitive_data_model_for_download_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r U r zqDataSafeClientCompositeOperations.generate_sensitive_data_model_for_download_and_wait_for_state.<locals>.<lambda>r N) r Z*generate_sensitive_data_model_for_downloadr r r r! r" r# r$ ) r r2 Z2generate_sensitive_data_model_for_download_detailsr& r' r( r) r* r+ r, r- r r r �=generate_sensitive_data_model_for_download_and_wait_for_state4 s( � ��z_DataSafeClientCompositeOperations.generate_sensitive_data_model_for_download_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.generate_sql_firewall_policy` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sql_collection_id: (required) The OCID of the SQL collection resource. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.generate_sql_firewall_policy` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r s r zeDataSafeClientCompositeOperations.generate_sql_firewall_policy_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r | r zcDataSafeClientCompositeOperations.generate_sql_firewall_policy_and_wait_for_state.<locals>.<lambda>r N) r Z generate_sql_firewall_policyr r r r! r" r# r$ � r rL r& r' r( r) r* r+ r, r- r r r �/generate_sql_firewall_policy_and_wait_for_state^ s( � ��zQDataSafeClientCompositeOperations.generate_sql_firewall_policy_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a{ Calls :py:func:`~oci.data_safe.DataSafeClient.generate_user_assessment_report` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str user_assessment_id: (required) The OCID of the user assessment. :param oci.data_safe.models.GenerateUserAssessmentReportDetails generate_user_assessment_report_details: (required) Details of the report. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.generate_user_assessment_report` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zhDataSafeClientCompositeOperations.generate_user_assessment_report_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zfDataSafeClientCompositeOperations.generate_user_assessment_report_and_wait_for_state.<locals>.<lambda>r N) r Z generate_user_assessment_reportr r r r! r" r# r$ ) r rR Z'generate_user_assessment_report_detailsr& r' r( r) r* r+ r, r- r r r �2generate_user_assessment_report_and_wait_for_state� s( � ��zTDataSafeClientCompositeOperations.generate_user_assessment_report_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a" Calls :py:func:`~oci.data_safe.DataSafeClient.mask_data` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str masking_policy_id: (required) The OCID of the masking policy. :param oci.data_safe.models.MaskDataDetails mask_data_details: (required) Details to mask data. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.mask_data` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zRDataSafeClientCompositeOperations.mask_data_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zPDataSafeClientCompositeOperations.mask_data_and_wait_for_state.<locals>.<lambda>r N) r Z mask_datar r r r! r" r# r$ ) r r/ Zmask_data_detailsr& r' r( r) r* r+ r, r- r r r � mask_data_and_wait_for_state� s( � ��z>DataSafeClientCompositeOperations.mask_data_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) ar Calls :py:func:`~oci.data_safe.DataSafeClient.modify_global_settings` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.ModifyGlobalSettingsDetails modify_global_settings_details: (required) The details used to update global settings in Data Safe. :param str compartment_id: (required) The OCID of the compartment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.modify_global_settings` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r z_DataSafeClientCompositeOperations.modify_global_settings_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z]DataSafeClientCompositeOperations.modify_global_settings_and_wait_for_state.<locals>.<lambda>r N) r Zmodify_global_settingsr r r r! r" r# r$ ) r Z modify_global_settings_detailsZcompartment_idr& r' r( r) r* r+ r, r- r r r �)modify_global_settings_and_wait_for_state� s( � ��zKDataSafeClientCompositeOperations.modify_global_settings_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a Calls :py:func:`~oci.data_safe.DataSafeClient.patch_alerts` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.PatchAlertsDetails patch_alerts_details: (required) The alert details to update the status of one or more alert specified by the alert IDs. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.patch_alerts` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r r zUDataSafeClientCompositeOperations.patch_alerts_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r ! r zSDataSafeClientCompositeOperations.patch_alerts_and_wait_for_state.<locals>.<lambda>r N) r Z patch_alertsr r r r! r" r# r$ ) r Zpatch_alerts_detailsr& r' r( r) r* r+ r, r- r r r � patch_alerts_and_wait_for_state s( � ��zADataSafeClientCompositeOperations.patch_alerts_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) ar Calls :py:func:`~oci.data_safe.DataSafeClient.patch_discovery_job_results` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str discovery_job_id: (required) The OCID of the discovery job. :param oci.data_safe.models.PatchDiscoveryJobResultDetails patch_discovery_job_result_details: (required) Details to patch discovery results. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.patch_discovery_job_results` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r B r zdDataSafeClientCompositeOperations.patch_discovery_job_results_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r K r zbDataSafeClientCompositeOperations.patch_discovery_job_results_and_wait_for_state.<locals>.<lambda>r N) r Zpatch_discovery_job_resultsr r r r! r" r# r$ ) r rs Z"patch_discovery_job_result_detailsr& r' r( r) r* r+ r, r- r r r �.patch_discovery_job_results_and_wait_for_state* s( � ��zPDataSafeClientCompositeOperations.patch_discovery_job_results_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a] Calls :py:func:`~oci.data_safe.DataSafeClient.patch_masking_columns` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str masking_policy_id: (required) The OCID of the masking policy. :param oci.data_safe.models.PatchMaskingColumnsDetails patch_masking_columns_details: (required) Details to patch masking columns. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.patch_masking_columns` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r l r z^DataSafeClientCompositeOperations.patch_masking_columns_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r u r z\DataSafeClientCompositeOperations.patch_masking_columns_and_wait_for_state.<locals>.<lambda>r N) r Zpatch_masking_columnsr r r r! r" r# r$ ) r r/ Z patch_masking_columns_detailsr& r' r( r) r* r+ r, r- r r r �(patch_masking_columns_and_wait_for_stateT s( � ��zJDataSafeClientCompositeOperations.patch_masking_columns_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.patch_sdm_masking_policy_difference_columns` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sdm_masking_policy_difference_id: (required) The OCID of the SDM masking policy difference. :param oci.data_safe.models.PatchSdmMaskingPolicyDifferenceColumnsDetails patch_sdm_masking_policy_difference_columns_details: (required) Details to patch difference columns. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.patch_sdm_masking_policy_difference_columns` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r ztDataSafeClientCompositeOperations.patch_sdm_masking_policy_difference_columns_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zrDataSafeClientCompositeOperations.patch_sdm_masking_policy_difference_columns_and_wait_for_state.<locals>.<lambda>r N) r Z+patch_sdm_masking_policy_difference_columnsr r r r! r" r# r$ ) r r� Z3patch_sdm_masking_policy_difference_columns_detailsr& r' r( r) r* r+ r, r- r r r �>patch_sdm_masking_policy_difference_columns_and_wait_for_state~ s( � ��z`DataSafeClientCompositeOperations.patch_sdm_masking_policy_difference_columns_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) aq Calls :py:func:`~oci.data_safe.DataSafeClient.patch_sensitive_columns` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sensitive_data_model_id: (required) The OCID of the sensitive data model. :param oci.data_safe.models.PatchSensitiveColumnDetails patch_sensitive_column_details: (required) Details to patch sensitive columns. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.patch_sensitive_columns` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r z`DataSafeClientCompositeOperations.patch_sensitive_columns_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z^DataSafeClientCompositeOperations.patch_sensitive_columns_and_wait_for_state.<locals>.<lambda>r N) r Zpatch_sensitive_columnsr r r r! r" r# r$ ) r r2 Z patch_sensitive_column_detailsr& r' r( r) r* r+ r, r- r r r �*patch_sensitive_columns_and_wait_for_state� s( � ��zLDataSafeClientCompositeOperations.patch_sensitive_columns_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a[ Calls :py:func:`~oci.data_safe.DataSafeClient.patch_target_alert_policy_association` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.PatchTargetAlertPolicyAssociationDetails patch_target_alert_policy_association_details: (required) The details used to patch the target-alert policy associations. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.patch_target_alert_policy_association` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r znDataSafeClientCompositeOperations.patch_target_alert_policy_association_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zlDataSafeClientCompositeOperations.patch_target_alert_policy_association_and_wait_for_state.<locals>.<lambda>r N) r Z%patch_target_alert_policy_associationr r r r! r" r# r$ ) r Z-patch_target_alert_policy_association_detailsr& r' r( r) r* r+ r, r- r r r �8patch_target_alert_policy_association_and_wait_for_state� s( � ��zZDataSafeClientCompositeOperations.patch_target_alert_policy_association_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.provision_audit_policy` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.ProvisionAuditPolicyDetails provision_audit_policy_details: (required) Details for provisioning the given policies on the source target database. :param str audit_policy_id: (required) Unique audit policy identifier. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.provision_audit_policy` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r r z_DataSafeClientCompositeOperations.provision_audit_policy_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r z]DataSafeClientCompositeOperations.provision_audit_policy_and_wait_for_state.<locals>.<lambda>r N) r Zprovision_audit_policyr r r r! r" r# r$ ) r Z provision_audit_policy_detailsr< r& r' r( r) r* r+ r, r- r r r �)provision_audit_policy_and_wait_for_state� s( � ��zKDataSafeClientCompositeOperations.provision_audit_policy_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.purge_sql_collection_logs` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sql_collection_id: (required) The OCID of the SQL collection resource. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.purge_sql_collection_logs` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r 8 r zbDataSafeClientCompositeOperations.purge_sql_collection_logs_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r A r z`DataSafeClientCompositeOperations.purge_sql_collection_logs_and_wait_for_state.<locals>.<lambda>r N) r Zpurge_sql_collection_logsr r r r! r" r# r$ r� r r r �,purge_sql_collection_logs_and_wait_for_state# s( � ��zNDataSafeClientCompositeOperations.purge_sql_collection_logs_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a Calls :py:func:`~oci.data_safe.DataSafeClient.refresh_database_security_configuration` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str database_security_config_id: (required) The OCID of the database security configuration resource. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.refresh_database_security_configuration` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r _ r zpDataSafeClientCompositeOperations.refresh_database_security_configuration_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r h r znDataSafeClientCompositeOperations.refresh_database_security_configuration_and_wait_for_state.<locals>.<lambda>r N) r Z'refresh_database_security_configurationr r r r! r" r# r$ ) r rA r& r' r( r) r* r+ r, r- r r r �:refresh_database_security_configuration_and_wait_for_stateJ s( � ��z\DataSafeClientCompositeOperations.refresh_database_security_configuration_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.refresh_security_assessment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str security_assessment_id: (required) The OCID of the security assessment. :param oci.data_safe.models.RunSecurityAssessmentDetails run_security_assessment_details: (required) Details to create an on-demand saved security assessment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.refresh_security_assessment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zdDataSafeClientCompositeOperations.refresh_security_assessment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zbDataSafeClientCompositeOperations.refresh_security_assessment_and_wait_for_state.<locals>.<lambda>r N) r Zrefresh_security_assessmentr r r r! r" r# r$ ) r rP Z run_security_assessment_detailsr& r' r( r) r* r+ r, r- r r r �.refresh_security_assessment_and_wait_for_stateq s( � ��zPDataSafeClientCompositeOperations.refresh_security_assessment_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.refresh_sql_collection_log_insights` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sql_collection_id: (required) The OCID of the SQL collection resource. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.refresh_sql_collection_log_insights` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zlDataSafeClientCompositeOperations.refresh_sql_collection_log_insights_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zjDataSafeClientCompositeOperations.refresh_sql_collection_log_insights_and_wait_for_state.<locals>.<lambda>r N) r Z#refresh_sql_collection_log_insightsr r r r! r" r# r$ r� r r r �6refresh_sql_collection_log_insights_and_wait_for_state� s( � ��zXDataSafeClientCompositeOperations.refresh_sql_collection_log_insights_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.refresh_target_database` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str target_database_id: (required) The OCID of the Data Safe target database. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.refresh_target_database` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r z`DataSafeClientCompositeOperations.refresh_target_database_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z^DataSafeClientCompositeOperations.refresh_target_database_and_wait_for_state.<locals>.<lambda>r N) r Zrefresh_target_databaser r r r! r" r# r$ rh r r r �*refresh_target_database_and_wait_for_state� s( � ��zLDataSafeClientCompositeOperations.refresh_target_database_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.refresh_user_assessment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str user_assessment_id: (required) The OCID of the user assessment. :param oci.data_safe.models.RunUserAssessmentDetails run_user_assessment_details: (required) The details required to create an on-demand saved user assessment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.refresh_user_assessment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r r z`DataSafeClientCompositeOperations.refresh_user_assessment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r z^DataSafeClientCompositeOperations.refresh_user_assessment_and_wait_for_state.<locals>.<lambda>r N) r Zrefresh_user_assessmentr r r r! r" r# r$ ) r rR Zrun_user_assessment_detailsr& r' r( r) r* r+ r, r- r r r �*refresh_user_assessment_and_wait_for_state� s( � ��zLDataSafeClientCompositeOperations.refresh_user_assessment_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.remove_schedule_report` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str report_definition_id: (required) Unique report definition identifier :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.remove_schedule_report` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r ( r z_DataSafeClientCompositeOperations.remove_schedule_report_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r 1 r z]DataSafeClientCompositeOperations.remove_schedule_report_and_wait_for_state.<locals>.<lambda>r N) r Zremove_schedule_reportr r r r! r" r# r$ ) r rE r& r' r( r) r* r+ r, r- r r r �)remove_schedule_report_and_wait_for_state s( � ��zKDataSafeClientCompositeOperations.remove_schedule_report_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.resume_audit_trail` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_trail_id: (required) The OCID of the audit trail. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.resume_audit_trail` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r O r z[DataSafeClientCompositeOperations.resume_audit_trail_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r X r zYDataSafeClientCompositeOperations.resume_audit_trail_and_wait_for_state.<locals>.<lambda>r N) r Zresume_audit_trailr r r r! r" r# r$ � r rp r& r' r( r) r* r+ r, r- r r r �%resume_audit_trail_and_wait_for_state: s( � ��zGDataSafeClientCompositeOperations.resume_audit_trail_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.retrieve_audit_policies` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_policy_id: (required) Unique audit policy identifier. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.retrieve_audit_policies` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r v r z`DataSafeClientCompositeOperations.retrieve_audit_policies_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r z^DataSafeClientCompositeOperations.retrieve_audit_policies_and_wait_for_state.<locals>.<lambda>r N) r Zretrieve_audit_policiesr r r r! r" r# r$ ) r r< r& r' r( r) r* r+ r, r- r r r �*retrieve_audit_policies_and_wait_for_statea s( � ��zLDataSafeClientCompositeOperations.retrieve_audit_policies_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.schedule_report` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str report_definition_id: (required) Unique report definition identifier :param oci.data_safe.models.ScheduleReportDetails schedule_report_details: (required) The details for the audit report schedule. It contains details such as schedule, MIME type .xls/.pdf and number of rows. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.schedule_report` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zXDataSafeClientCompositeOperations.schedule_report_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zVDataSafeClientCompositeOperations.schedule_report_and_wait_for_state.<locals>.<lambda>r N) r Zschedule_reportr r r r! r" r# r$ ) r rE Zschedule_report_detailsr& r' r( r) r* r+ r, r- r r r �"schedule_report_and_wait_for_state� s( � ��zDDataSafeClientCompositeOperations.schedule_report_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.set_security_assessment_baseline` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str security_assessment_id: (required) The OCID of the security assessment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.set_security_assessment_baseline` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r ziDataSafeClientCompositeOperations.set_security_assessment_baseline_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zgDataSafeClientCompositeOperations.set_security_assessment_baseline_and_wait_for_state.<locals>.<lambda>r N) r Z set_security_assessment_baseliner r r r! r" r# r$ � r rP r& r' r( r) r* r+ r, r- r r r �3set_security_assessment_baseline_and_wait_for_state� s( � ��zUDataSafeClientCompositeOperations.set_security_assessment_baseline_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.set_user_assessment_baseline` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str user_assessment_id: (required) The OCID of the user assessment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.set_user_assessment_baseline` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zeDataSafeClientCompositeOperations.set_user_assessment_baseline_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zcDataSafeClientCompositeOperations.set_user_assessment_baseline_and_wait_for_state.<locals>.<lambda>r N) r Z set_user_assessment_baseliner r r r! r" r# r$ � r rR r& r' r( r) r* r+ r, r- r r r �/set_user_assessment_baseline_and_wait_for_state� s( � ��zQDataSafeClientCompositeOperations.set_user_assessment_baseline_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) aE Calls :py:func:`~oci.data_safe.DataSafeClient.start_audit_trail` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.StartAuditTrailDetails start_audit_trail_details: (required) Details for the starting audit. :param str audit_trail_id: (required) The OCID of the audit trail. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.start_audit_trail` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r r zZDataSafeClientCompositeOperations.start_audit_trail_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r ! r zXDataSafeClientCompositeOperations.start_audit_trail_and_wait_for_state.<locals>.<lambda>r N) r Zstart_audit_trailr r r r! r" r# r$ ) r Zstart_audit_trail_detailsrp r& r' r( r) r* r+ r, r- r r r �$start_audit_trail_and_wait_for_state s( � ��zFDataSafeClientCompositeOperations.start_audit_trail_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.start_sql_collection` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sql_collection_id: (required) The OCID of the SQL collection resource. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.start_sql_collection` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r ? r z]DataSafeClientCompositeOperations.start_sql_collection_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r H r z[DataSafeClientCompositeOperations.start_sql_collection_and_wait_for_state.<locals>.<lambda>r N) r Zstart_sql_collectionr r r r! r" r# r$ r� r r r �'start_sql_collection_and_wait_for_state* s( � ��zIDataSafeClientCompositeOperations.start_sql_collection_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.stop_audit_trail` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_trail_id: (required) The OCID of the audit trail. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.stop_audit_trail` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r f r zYDataSafeClientCompositeOperations.stop_audit_trail_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r o r zWDataSafeClientCompositeOperations.stop_audit_trail_and_wait_for_state.<locals>.<lambda>r N) r Zstop_audit_trailr r r r! r" r# r$ r� r r r �#stop_audit_trail_and_wait_for_stateQ s( � ��zEDataSafeClientCompositeOperations.stop_audit_trail_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.stop_sql_collection` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sql_collection_id: (required) The OCID of the SQL collection resource. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.stop_sql_collection` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r z\DataSafeClientCompositeOperations.stop_sql_collection_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zZDataSafeClientCompositeOperations.stop_sql_collection_and_wait_for_state.<locals>.<lambda>r N) r Zstop_sql_collectionr r r r! r" r# r$ r� r r r �&stop_sql_collection_and_wait_for_statex s( � ��zHDataSafeClientCompositeOperations.stop_sql_collection_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.unset_security_assessment_baseline` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str security_assessment_id: (required) The OCID of the security assessment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.unset_security_assessment_baseline` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zkDataSafeClientCompositeOperations.unset_security_assessment_baseline_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r ziDataSafeClientCompositeOperations.unset_security_assessment_baseline_and_wait_for_state.<locals>.<lambda>r N) r Z"unset_security_assessment_baseliner r r r! r" r# r$ r� r r r �5unset_security_assessment_baseline_and_wait_for_state� s( � ��zWDataSafeClientCompositeOperations.unset_security_assessment_baseline_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� d|jvr8|S |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.unset_user_assessment_baseline` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str user_assessment_id: (required) The OCID of the user assessment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.unset_user_assessment_baseline` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zgDataSafeClientCompositeOperations.unset_user_assessment_baseline_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zeDataSafeClientCompositeOperations.unset_user_assessment_baseline_and_wait_for_state.<locals>.<lambda>r N) r Z unset_user_assessment_baseliner r r r! r" r# r$ r� r r r �1unset_user_assessment_baseline_and_wait_for_state� s( � ��zSDataSafeClientCompositeOperations.unset_user_assessment_baseline_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a3 Calls :py:func:`~oci.data_safe.DataSafeClient.update_alert` and waits for the :py:class:`~oci.data_safe.models.Alert` acted upon to enter the given state(s). :param str alert_id: (required) The OCID of alert. :param oci.data_safe.models.UpdateAlertDetails update_alert_details: (required) The details used to update alert status. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.Alert.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_alert` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r r zUDataSafeClientCompositeOperations.update_alert_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S rv r r r r r r r zSDataSafeClientCompositeOperations.update_alert_and_wait_for_state.<locals>.<lambda>rw ry r N) r Z update_alertr �idr r Z get_alertr} r~ r r# r$ r" ) r Zalert_idZupdate_alert_detailsr& r' r( r) r+ r, r- r r r � update_alert_and_wait_for_state� s. � �� &zADataSafeClientCompositeOperations.update_alert_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a\ Calls :py:func:`~oci.data_safe.DataSafeClient.update_alert_policy` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str alert_policy_id: (required) The OCID of the alert policy. :param oci.data_safe.models.UpdateAlertPolicyDetails update_alert_policy_details: (required) The details used to update the alert policy. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_alert_policy` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r 2 r z\DataSafeClientCompositeOperations.update_alert_policy_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r ; r zZDataSafeClientCompositeOperations.update_alert_policy_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_alert_policyr r r r! r" r# r$ ) r r8 Zupdate_alert_policy_detailsr& r' r( r) r* r+ r, r- r r r �&update_alert_policy_and_wait_for_state s( � ��zHDataSafeClientCompositeOperations.update_alert_policy_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� d|jvr<|S |jd }z4tj| j | j �|�fd� fdd�i|��} | } | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.update_alert_policy_rule` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str alert_policy_id: (required) The OCID of the alert policy. :param str rule_key: (required) The key of the alert policy rule. :param oci.data_safe.models.UpdateAlertPolicyRuleDetails update_alert_policy_rule_details: (required) The details used to update the alert policy rule. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_alert_policy_rule` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r _ r zaDataSafeClientCompositeOperations.update_alert_policy_rule_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r h r z_DataSafeClientCompositeOperations.update_alert_policy_rule_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_alert_policy_ruler r r r! r" r# r$ ) r r8 rm Z update_alert_policy_rule_detailsr& r' r( r) r* r+ r, r- r r r �+update_alert_policy_rule_and_wait_for_stateD s( � ��zMDataSafeClientCompositeOperations.update_alert_policy_rule_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.update_audit_archive_retrieval` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_archive_retrieval_id: (required) OCID of the archive retrieval. :param oci.data_safe.models.UpdateAuditArchiveRetrievalDetails update_audit_archive_retrieval_details: (required) Details to update the audit archive retrieval. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_audit_archive_retrieval` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zgDataSafeClientCompositeOperations.update_audit_archive_retrieval_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zeDataSafeClientCompositeOperations.update_audit_archive_retrieval_and_wait_for_state.<locals>.<lambda>r N) r Z update_audit_archive_retrievalr r r r! r" r# r$ ) r r: Z&update_audit_archive_retrieval_detailsr& r' r( r) r* r+ r, r- r r r �1update_audit_archive_retrieval_and_wait_for_stateq s( � ��zSDataSafeClientCompositeOperations.update_audit_archive_retrieval_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) aU Calls :py:func:`~oci.data_safe.DataSafeClient.update_audit_policy` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_policy_id: (required) Unique audit policy identifier. :param oci.data_safe.models.UpdateAuditPolicyDetails update_audit_policy_details: (required) Details to update the audit policy. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_audit_policy` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r z\DataSafeClientCompositeOperations.update_audit_policy_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zZDataSafeClientCompositeOperations.update_audit_policy_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_audit_policyr r r r! r" r# r$ ) r r< Zupdate_audit_policy_detailsr& r' r( r) r* r+ r, r- r r r �&update_audit_policy_and_wait_for_state� s( � ��zHDataSafeClientCompositeOperations.update_audit_policy_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) aL Calls :py:func:`~oci.data_safe.DataSafeClient.update_audit_profile` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_profile_id: (required) The OCID of the audit. :param oci.data_safe.models.UpdateAuditProfileDetails update_audit_profile_details: (required) The information to be updated. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_audit_profile` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r z]DataSafeClientCompositeOperations.update_audit_profile_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z[DataSafeClientCompositeOperations.update_audit_profile_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_audit_profiler r r r! r" r# r$ ) r r5 Z update_audit_profile_detailsr& r' r( r) r* r+ r, r- r r r �'update_audit_profile_and_wait_for_state� s( � ��zIDataSafeClientCompositeOperations.update_audit_profile_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) aH Calls :py:func:`~oci.data_safe.DataSafeClient.update_audit_trail` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str audit_trail_id: (required) The OCID of the audit trail. :param oci.data_safe.models.UpdateAuditTrailDetails update_audit_trail_details: (required) The information to be updated. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_audit_trail` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r r z[DataSafeClientCompositeOperations.update_audit_trail_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r zYDataSafeClientCompositeOperations.update_audit_trail_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_audit_trailr r r r! r" r# r$ ) r rp Zupdate_audit_trail_detailsr& r' r( r) r* r+ r, r- r r r �%update_audit_trail_and_wait_for_state� s( � ��zGDataSafeClientCompositeOperations.update_audit_trail_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.update_data_safe_private_endpoint` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str data_safe_private_endpoint_id: (required) The OCID of the private endpoint. :param oci.data_safe.models.UpdateDataSafePrivateEndpointDetails update_data_safe_private_endpoint_details: (required) The details used to update a Data Safe private endpoint. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_data_safe_private_endpoint` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r 1 r zjDataSafeClientCompositeOperations.update_data_safe_private_endpoint_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r : r zhDataSafeClientCompositeOperations.update_data_safe_private_endpoint_and_wait_for_state.<locals>.<lambda>r N) r Z!update_data_safe_private_endpointr r r r! r" r# r$ ) r r? Z)update_data_safe_private_endpoint_detailsr& r' r( r) r* r+ r, r- r r r �4update_data_safe_private_endpoint_and_wait_for_state s( � ��zVDataSafeClientCompositeOperations.update_data_safe_private_endpoint_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.update_database_security_config` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str database_security_config_id: (required) The OCID of the database security configuration resource. :param oci.data_safe.models.UpdateDatabaseSecurityConfigDetails update_database_security_config_details: (required) Details to update the database security configuration. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_database_security_config` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r [ r zhDataSafeClientCompositeOperations.update_database_security_config_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r d r zfDataSafeClientCompositeOperations.update_database_security_config_and_wait_for_state.<locals>.<lambda>r N) r Z update_database_security_configr r r r! r" r# r$ ) r rA Z'update_database_security_config_detailsr& r' r( r) r* r+ r, r- r r r �2update_database_security_config_and_wait_for_stateC s( � ��zTDataSafeClientCompositeOperations.update_database_security_config_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� d|jvr<|S |jd }z4tj| j | j �|�fd� fdd�i|��} | } | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.update_finding` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str security_assessment_id: (required) The OCID of the security assessment. :param str finding_key: (required) The unique key that identifies the finding. It is a string and unique within a security assessment. :param oci.data_safe.models.UpdateFindingDetails update_finding_details: (required) Details to change risk of a finding. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_finding` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zWDataSafeClientCompositeOperations.update_finding_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zUDataSafeClientCompositeOperations.update_finding_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_findingr r r r! r" r# r$ ) r rP Z finding_keyZupdate_finding_detailsr& r' r( r) r* r+ r, r- r r r �!update_finding_and_wait_for_statem s( � ��zCDataSafeClientCompositeOperations.update_finding_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.update_library_masking_format` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str library_masking_format_id: (required) The OCID of the library masking format. :param oci.data_safe.models.UpdateLibraryMaskingFormatDetails update_library_masking_format_details: (required) Details to update a library masking format. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_library_masking_format` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zfDataSafeClientCompositeOperations.update_library_masking_format_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zdDataSafeClientCompositeOperations.update_library_masking_format_and_wait_for_state.<locals>.<lambda>r N) r Z update_library_masking_formatr r r r! r" r# r$ ) r r� Z%update_library_masking_format_detailsr& r' r( r) r* r+ r, r- r r r �0update_library_masking_format_and_wait_for_state� s( � ��zRDataSafeClientCompositeOperations.update_library_masking_format_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� d|jvr<|S |jd }z4tj| j | j �|�fd� fdd�i|��} | } | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a Calls :py:func:`~oci.data_safe.DataSafeClient.update_masking_column` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str masking_column_key: (required) The unique key that identifies the masking column. It's numeric and unique within a masking policy. :param str masking_policy_id: (required) The OCID of the masking policy. :param oci.data_safe.models.UpdateMaskingColumnDetails update_masking_column_details: (required) Details to update a masking column. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_masking_column` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r z^DataSafeClientCompositeOperations.update_masking_column_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z\DataSafeClientCompositeOperations.update_masking_column_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_masking_columnr r r r! r" r# r$ ) r Zmasking_column_keyr/ Z update_masking_column_detailsr& r' r( r) r* r+ r, r- r r r �(update_masking_column_and_wait_for_state� s( � ��zJDataSafeClientCompositeOperations.update_masking_column_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a_ Calls :py:func:`~oci.data_safe.DataSafeClient.update_masking_policy` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str masking_policy_id: (required) The OCID of the masking policy. :param oci.data_safe.models.UpdateMaskingPolicyDetails update_masking_policy_details: (required) Details to update a masking policy. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_masking_policy` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r r z^DataSafeClientCompositeOperations.update_masking_policy_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r z\DataSafeClientCompositeOperations.update_masking_policy_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_masking_policyr r r r! r" r# r$ ) r r/ Z update_masking_policy_detailsr& r' r( r) r* r+ r, r- r r r �(update_masking_policy_and_wait_for_state� s( � ��zJDataSafeClientCompositeOperations.update_masking_policy_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.update_on_prem_connector` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str on_prem_connector_id: (required) The OCID of the on-premises connector. :param oci.data_safe.models.UpdateOnPremConnectorDetails update_on_prem_connector_details: (required) The details used to update a on-premises connector. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_on_prem_connector` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r 3 r zaDataSafeClientCompositeOperations.update_on_prem_connector_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r < r z_DataSafeClientCompositeOperations.update_on_prem_connector_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_on_prem_connectorr r r r! r" r# r$ ) r r� Z update_on_prem_connector_detailsr& r' r( r) r* r+ r, r- r r r �+update_on_prem_connector_and_wait_for_state s( � ��zMDataSafeClientCompositeOperations.update_on_prem_connector_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.update_on_prem_connector_wallet` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param oci.data_safe.models.UpdateOnPremConnectorWalletDetails update_on_prem_connector_wallet_details: (required) The details used to update an on-premises connector's wallet. :param str on_prem_connector_id: (required) The OCID of the on-premises connector. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_on_prem_connector_wallet` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r ] r zhDataSafeClientCompositeOperations.update_on_prem_connector_wallet_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r f r zfDataSafeClientCompositeOperations.update_on_prem_connector_wallet_and_wait_for_state.<locals>.<lambda>r N) r Z update_on_prem_connector_walletr r r r! r" r# r$ ) r Z'update_on_prem_connector_wallet_detailsr� r& r' r( r) r* r+ r, r- r r r �2update_on_prem_connector_wallet_and_wait_for_stateE s( � ��zTDataSafeClientCompositeOperations.update_on_prem_connector_wallet_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� d|jvr<|S |jd }z4tj| j | j �|�fd� fdd�i|��} | } | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a Calls :py:func:`~oci.data_safe.DataSafeClient.update_peer_target_database` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str target_database_id: (required) The OCID of the Data Safe target database. :param int peer_target_database_id: (required) The unique id of the peer target database. :param oci.data_safe.models.UpdatePeerTargetDatabaseDetails update_peer_target_database_details: (required) Database details to be used to update the peer target database. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_peer_target_database` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zdDataSafeClientCompositeOperations.update_peer_target_database_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zbDataSafeClientCompositeOperations.update_peer_target_database_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_peer_target_databaser r r r! r" r# r$ ) r r% r� Z#update_peer_target_database_detailsr& r' r( r) r* r+ r, r- r r r �.update_peer_target_database_and_wait_for_stateo s( � ��zPDataSafeClientCompositeOperations.update_peer_target_database_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a. Calls :py:func:`~oci.data_safe.DataSafeClient.update_report` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str report_id: (required) Unique report identifier :param oci.data_safe.models.UpdateReportDetails update_report_details: (required) Details for the modified report. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_report` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zVDataSafeClientCompositeOperations.update_report_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zTDataSafeClientCompositeOperations.update_report_and_wait_for_state.<locals>.<lambda>r N) r Z update_reportr r r r! r" r# r$ ) r rC Zupdate_report_detailsr& r' r( r) r* r+ r, r- r r r � update_report_and_wait_for_state� s( � ��zBDataSafeClientCompositeOperations.update_report_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) az Calls :py:func:`~oci.data_safe.DataSafeClient.update_report_definition` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str report_definition_id: (required) Unique report definition identifier :param oci.data_safe.models.UpdateReportDefinitionDetails update_report_definition_details: (required) Details for the modified report definition. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_report_definition` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zaDataSafeClientCompositeOperations.update_report_definition_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z_DataSafeClientCompositeOperations.update_report_definition_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_report_definitionr r r r! r" r# r$ ) r rE Z update_report_definition_detailsr& r' r( r) r* r+ r, r- r r r �+update_report_definition_and_wait_for_state� s( � ��zMDataSafeClientCompositeOperations.update_report_definition_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.update_sdm_masking_policy_difference` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sdm_masking_policy_difference_id: (required) The OCID of the SDM masking policy difference. :param oci.data_safe.models.UpdateSdmMaskingPolicyDifferenceDetails update_sdm_masking_policy_difference_details: (required) Details to update a sdm masking policy difference. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_sdm_masking_policy_difference` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r r zmDataSafeClientCompositeOperations.update_sdm_masking_policy_difference_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r zkDataSafeClientCompositeOperations.update_sdm_masking_policy_difference_and_wait_for_state.<locals>.<lambda>r N) r Z$update_sdm_masking_policy_differencer r r r! r" r# r$ ) r r� Z,update_sdm_masking_policy_difference_detailsr& r' r( r) r* r+ r, r- r r r �7update_sdm_masking_policy_difference_and_wait_for_state� s( � ��zYDataSafeClientCompositeOperations.update_sdm_masking_policy_difference_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) ax Calls :py:func:`~oci.data_safe.DataSafeClient.update_security_assessment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str security_assessment_id: (required) The OCID of the security assessment. :param oci.data_safe.models.UpdateSecurityAssessmentDetails update_security_assessment_details: (required) The information to be updated. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_security_assessment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r 2 r zcDataSafeClientCompositeOperations.update_security_assessment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r ; r zaDataSafeClientCompositeOperations.update_security_assessment_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_security_assessmentr r r r! r" r# r$ ) r rP Z"update_security_assessment_detailsr& r' r( r) r* r+ r, r- r r r �-update_security_assessment_and_wait_for_state s( � ��zODataSafeClientCompositeOperations.update_security_assessment_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) aq Calls :py:func:`~oci.data_safe.DataSafeClient.update_security_policy` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str security_policy_id: (required) The OCID of the security policy resource. :param oci.data_safe.models.UpdateSecurityPolicyDetails update_security_policy_details: (required) Details to update the security policy. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_security_policy` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r \ r z_DataSafeClientCompositeOperations.update_security_policy_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r e r z]DataSafeClientCompositeOperations.update_security_policy_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_security_policyr r r r! r" r# r$ ) r rH Z update_security_policy_detailsr& r' r( r) r* r+ r, r- r r r �)update_security_policy_and_wait_for_stateD s( � ��zKDataSafeClientCompositeOperations.update_security_policy_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.update_security_policy_deployment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str security_policy_deployment_id: (required) The OCID of the security policy deployment resource. :param oci.data_safe.models.UpdateSecurityPolicyDeploymentDetails update_security_policy_deployment_details: (required) Details to update the security policy deployment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_security_policy_deployment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zjDataSafeClientCompositeOperations.update_security_policy_deployment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zhDataSafeClientCompositeOperations.update_security_policy_deployment_and_wait_for_state.<locals>.<lambda>r N) r Z!update_security_policy_deploymentr r r r! r" r# r$ ) r rJ Z)update_security_policy_deployment_detailsr& r' r( r) r* r+ r, r- r r r �4update_security_policy_deployment_and_wait_for_staten s( � ��zVDataSafeClientCompositeOperations.update_security_policy_deployment_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� d|jvr<|S |jd }z4tj| j | j �|�fd� fdd�i|��} | } | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a" Calls :py:func:`~oci.data_safe.DataSafeClient.update_sensitive_column` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sensitive_data_model_id: (required) The OCID of the sensitive data model. :param str sensitive_column_key: (required) The unique key that identifies the sensitive column. It's numeric and unique within a sensitive data model. :param oci.data_safe.models.UpdateSensitiveColumnDetails update_sensitive_column_details: (required) Details to update a sensitive column. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_sensitive_column` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r z`DataSafeClientCompositeOperations.update_sensitive_column_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z^DataSafeClientCompositeOperations.update_sensitive_column_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_sensitive_columnr r r r! r" r# r$ ) r r2 Zsensitive_column_keyZ update_sensitive_column_detailsr& r' r( r) r* r+ r, r- r r r �*update_sensitive_column_and_wait_for_state� s( � ��zLDataSafeClientCompositeOperations.update_sensitive_column_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.update_sensitive_data_model` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sensitive_data_model_id: (required) The OCID of the sensitive data model. :param oci.data_safe.models.UpdateSensitiveDataModelDetails update_sensitive_data_model_details: (required) Details to update a sensitive data model. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_sensitive_data_model` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zdDataSafeClientCompositeOperations.update_sensitive_data_model_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zbDataSafeClientCompositeOperations.update_sensitive_data_model_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_sensitive_data_modelr r r r! r" r# r$ ) r r2 Z#update_sensitive_data_model_detailsr& r' r( r) r* r+ r, r- r r r �.update_sensitive_data_model_and_wait_for_state� s( � ��zPDataSafeClientCompositeOperations.update_sensitive_data_model_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a_ Calls :py:func:`~oci.data_safe.DataSafeClient.update_sensitive_type` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sensitive_type_id: (required) The OCID of the sensitive type. :param oci.data_safe.models.UpdateSensitiveTypeDetails update_sensitive_type_details: (required) Details to update a sensitive type. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_sensitive_type` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r r z^DataSafeClientCompositeOperations.update_sensitive_type_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r z\DataSafeClientCompositeOperations.update_sensitive_type_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_sensitive_typer r r r! r" r# r$ ) r r� Z update_sensitive_type_detailsr& r' r( r) r* r+ r, r- r r r �(update_sensitive_type_and_wait_for_state� s( � ��zJDataSafeClientCompositeOperations.update_sensitive_type_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) aj Calls :py:func:`~oci.data_safe.DataSafeClient.update_sql_collection` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sql_collection_id: (required) The OCID of the SQL collection resource. :param oci.data_safe.models.UpdateSqlCollectionDetails update_sql_collection_details: (required) Details to update the SQL collection. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_sql_collection` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r 1 r z^DataSafeClientCompositeOperations.update_sql_collection_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r : r z\DataSafeClientCompositeOperations.update_sql_collection_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_sql_collectionr r r r! r" r# r$ ) r rL Z update_sql_collection_detailsr& r' r( r) r* r+ r, r- r r r �(update_sql_collection_and_wait_for_state s( � ��zJDataSafeClientCompositeOperations.update_sql_collection_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.update_sql_firewall_policy` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sql_firewall_policy_id: (required) The OCID of the SQL Firewall policy resource. :param oci.data_safe.models.UpdateSqlFirewallPolicyDetails update_sql_firewall_policy_details: (required) Details to update the SQL Firewall policy. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_sql_firewall_policy` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r [ r zcDataSafeClientCompositeOperations.update_sql_firewall_policy_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r d r zaDataSafeClientCompositeOperations.update_sql_firewall_policy_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_sql_firewall_policyr r r r! r" r# r$ ) r rN Z"update_sql_firewall_policy_detailsr& r' r( r) r* r+ r, r- r r r �-update_sql_firewall_policy_and_wait_for_stateC s( � ��zODataSafeClientCompositeOperations.update_sql_firewall_policy_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.update_target_alert_policy_association` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str target_alert_policy_association_id: (required) The OCID of the target-alert policy association. :param oci.data_safe.models.UpdateTargetAlertPolicyAssociationDetails update_target_alert_policy_association_details: (required) The details used to update the target-alert policy association. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_target_alert_policy_association` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r zoDataSafeClientCompositeOperations.update_target_alert_policy_association_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zmDataSafeClientCompositeOperations.update_target_alert_policy_association_and_wait_for_state.<locals>.<lambda>r N) r Z&update_target_alert_policy_associationr r r r! r" r# r$ ) r r� Z.update_target_alert_policy_association_detailsr& r' r( r) r* r+ r, r- r r r �9update_target_alert_policy_association_and_wait_for_statem s( � ��z[DataSafeClientCompositeOperations.update_target_alert_policy_association_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_safe.DataSafeClient.update_target_database` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str target_database_id: (required) The OCID of the Data Safe target database. :param oci.data_safe.models.UpdateTargetDatabaseDetails update_target_database_details: (required) Details used to update the target database in Data Safe. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_target_database` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r z_DataSafeClientCompositeOperations.update_target_database_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z]DataSafeClientCompositeOperations.update_target_database_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_target_databaser r r r! r" r# r$ ) r r% Z update_target_database_detailsr& r' r( r) r* r+ r, r- r r r �)update_target_database_and_wait_for_state� s( � ��zKDataSafeClientCompositeOperations.update_target_database_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a` Calls :py:func:`~oci.data_safe.DataSafeClient.update_user_assessment` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str user_assessment_id: (required) The OCID of the user assessment. :param oci.data_safe.models.UpdateUserAssessmentDetails update_user_assessment_details: (required) The information to be updated. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.update_user_assessment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r � r z_DataSafeClientCompositeOperations.update_user_assessment_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z]DataSafeClientCompositeOperations.update_user_assessment_and_wait_for_state.<locals>.<lambda>r N) r Zupdate_user_assessmentr r r r! r" r# r$ ) r rR Z update_user_assessment_detailsr& r' r( r) r* r+ r, r- r r r �)update_user_assessment_and_wait_for_state� s( � ��zKDataSafeClientCompositeOperations.update_user_assessment_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a; Calls :py:func:`~oci.data_safe.DataSafeClient.upload_masking_policy` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param stream upload_masking_policy_details: (required) Details to upload a masking policy file. :param str masking_policy_id: (required) The OCID of the masking policy. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.upload_masking_policy` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r r z^DataSafeClientCompositeOperations.upload_masking_policy_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r z\DataSafeClientCompositeOperations.upload_masking_policy_and_wait_for_state.<locals>.<lambda>r N) r Zupload_masking_policyr r r r! r" r# r$ ) r Z upload_masking_policy_detailsr/ r& r' r( r) r* r+ r, r- r r r �(upload_masking_policy_and_wait_for_state� s( � ��zJDataSafeClientCompositeOperations.upload_masking_policy_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� d|jvr:|S |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a_ Calls :py:func:`~oci.data_safe.DataSafeClient.upload_sensitive_data_model` and waits for the :py:class:`~oci.data_safe.models.WorkRequest` to enter the given state(s). :param str sensitive_data_model_id: (required) The OCID of the sensitive data model. :param stream upload_sensitive_data_model_details: (required) Details to upload a sensitive data model file. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_safe.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_safe.DataSafeClient.upload_sensitive_data_model` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait c S s g | ] }|� � �qS r r r r r r r - r zdDataSafeClientCompositeOperations.upload_sensitive_data_model_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r 6 r zbDataSafeClientCompositeOperations.upload_sensitive_data_model_and_wait_for_state.<locals>.<lambda>r N) r Zupload_sensitive_data_modelr r r r! r" r# r$ ) r r2 Z#upload_sensitive_data_model_detailsr& r' r( r) r* r+ r, r- r r r �.upload_sensitive_data_model_and_wait_for_state s( � ��zPDataSafeClientCompositeOperations.upload_sensitive_data_model_and_wait_for_stateN)��__name__� __module__� __qualname__�__doc__r r. r0 r1 r3 r4 r6 r7 r9 r; r= r> r@ rB rD rF rG rI rK rM rO rQ rS rT rU rV rW rX rY rZ r[ r\ r] r^ r_ r` ra rb rc rd re rf rg ri rl rn ro rq rr rt r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r s *''*******************'*''''*''*'''*'''''''/2////;///2////;/////''*******'***'****'*''*''*'''*''*'''''-*-******-*-***-******-********r )r Zoci.utilr �objectr r r r r �<module> s