oci 2.134.0__py3-none-any.whl → 2.135.0__py3-none-any.whl

oci/data_safe/data_safe_client_composite_operations.py

@@ -229,6 +229,84 @@ class DataSafeClientCompositeOperations(object):
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
+    def bulk_create_sql_firewall_allowed_sqls_and_wait_for_state(self, bulk_create_sql_firewall_allowed_sqls_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_safe.DataSafeClient.bulk_create_sql_firewall_allowed_sqls` and waits for the :py:class:`~oci.data_safe.models.WorkRequest`
+        to enter the given state(s).
+
+        :param oci.data_safe.models.BulkCreateSqlFirewallAllowedSqlsDetails bulk_create_sql_firewall_allowed_sqls_details: (required)
+            Details of the allowed sql.
+
+        :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.bulk_create_sql_firewall_allowed_sqls`
+
+        :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
+        """
+        operation_result = self.client.bulk_create_sql_firewall_allowed_sqls(bulk_create_sql_firewall_allowed_sqls_details, **operation_kwargs)
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        if 'opc-work-request-id' not in operation_result.headers:
+            return operation_result
+        wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_work_request(wait_for_resource_id),
+                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
+    def bulk_delete_sql_firewall_allowed_sqls_and_wait_for_state(self, bulk_delete_sql_firewall_allowed_sqls_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_safe.DataSafeClient.bulk_delete_sql_firewall_allowed_sqls` and waits for the :py:class:`~oci.data_safe.models.WorkRequest`
+        to enter the given state(s).
+
+        :param oci.data_safe.models.BulkDeleteSqlFirewallAllowedSqlsDetails bulk_delete_sql_firewall_allowed_sqls_details: (required)
+            Details of the allowed sql to be deleted from 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.bulk_delete_sql_firewall_allowed_sqls`
+
+        :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
+        """
+        operation_result = self.client.bulk_delete_sql_firewall_allowed_sqls(bulk_delete_sql_firewall_allowed_sqls_details, **operation_kwargs)
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        if 'opc-work-request-id' not in operation_result.headers:
+            return operation_result
+        wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_work_request(wait_for_resource_id),
+                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
     def calculate_audit_volume_available_and_wait_for_state(self, audit_profile_id, calculate_audit_volume_available_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
         Calls :py:func:`~oci.data_safe.DataSafeClient.calculate_audit_volume_available` and waits for the :py:class:`~oci.data_safe.models.WorkRequest`
@@ -2603,6 +2681,53 @@ class DataSafeClientCompositeOperations(object):
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
+    def delete_sql_firewall_allowed_sql_and_wait_for_state(self, sql_firewall_allowed_sql_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_safe.DataSafeClient.delete_sql_firewall_allowed_sql` and waits for the :py:class:`~oci.data_safe.models.WorkRequest`
+        to enter the given state(s).
+
+        :param str sql_firewall_allowed_sql_id: (required)
+            The OCID of the sqlFirewallAllowedSql 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_allowed_sql`
+
+        :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
+        """
+        operation_result = None
+        try:
+            operation_result = self.client.delete_sql_firewall_allowed_sql(sql_firewall_allowed_sql_id, **operation_kwargs)
+        except oci.exceptions.ServiceError as e:
+            if e.status == 404:
+                return WAIT_RESOURCE_NOT_FOUND
+            else:
+                raise e
+
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        if 'opc-work-request-id' not in operation_result.headers:
+            return operation_result
+        wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_work_request(wait_for_resource_id),
+                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
     def delete_sql_firewall_policy_and_wait_for_state(self, sql_firewall_policy_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
         Calls :py:func:`~oci.data_safe.DataSafeClient.delete_sql_firewall_policy` and waits for the :py:class:`~oci.data_safe.models.WorkRequest`
@@ -3535,6 +3660,45 @@ class DataSafeClientCompositeOperations(object):
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
+    def patch_sql_firewall_allowed_sql_and_wait_for_state(self, patch_sql_firewall_allowed_sql_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_safe.DataSafeClient.patch_sql_firewall_allowed_sql` and waits for the :py:class:`~oci.data_safe.models.WorkRequest`
+        to enter the given state(s).
+
+        :param oci.data_safe.models.PatchSqlFirewallAllowedSqlDetails patch_sql_firewall_allowed_sql_details: (required)
+            The details used to patch the allowed sqls.
+
+        :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_sql_firewall_allowed_sql`
+
+        :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
+        """
+        operation_result = self.client.patch_sql_firewall_allowed_sql(patch_sql_firewall_allowed_sql_details, **operation_kwargs)
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        if 'opc-work-request-id' not in operation_result.headers:
+            return operation_result
+        wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_work_request(wait_for_resource_id),
+                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
     def patch_target_alert_policy_association_and_wait_for_state(self, patch_target_alert_policy_association_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
         Calls :py:func:`~oci.data_safe.DataSafeClient.patch_target_alert_policy_association` and waits for the :py:class:`~oci.data_safe.models.WorkRequest`

oci/data_safe/models/__init__.py

@@ -53,6 +53,8 @@ from .audit_trail_summary import AuditTrailSummary
 from .autonomous_database_details import AutonomousDatabaseDetails
 from .available_audit_volume_collection import AvailableAuditVolumeCollection
 from .available_audit_volume_summary import AvailableAuditVolumeSummary
+from .bulk_create_sql_firewall_allowed_sqls_details import BulkCreateSqlFirewallAllowedSqlsDetails
+from .bulk_delete_sql_firewall_allowed_sqls_details import BulkDeleteSqlFirewallAllowedSqlsDetails
 from .calculate_audit_volume_available_details import CalculateAuditVolumeAvailableDetails
 from .calculate_audit_volume_collected_details import CalculateAuditVolumeCollectedDetails
 from .change_alert_compartment_details import ChangeAlertCompartmentDetails
@@ -194,6 +196,7 @@ from .library_masking_format import LibraryMaskingFormat
 from .library_masking_format_collection import LibraryMaskingFormatCollection
 from .library_masking_format_entry import LibraryMaskingFormatEntry
 from .library_masking_format_summary import LibraryMaskingFormatSummary
+from .list_selection_mode import ListSelectionMode
 from .mask_data_details import MaskDataDetails
 from .masked_column_collection import MaskedColumnCollection
 from .masked_column_summary import MaskedColumnSummary
@@ -236,6 +239,7 @@ from .patch_merge_instruction import PatchMergeInstruction
 from .patch_remove_instruction import PatchRemoveInstruction
 from .patch_sdm_masking_policy_difference_columns_details import PatchSdmMaskingPolicyDifferenceColumnsDetails
 from .patch_sensitive_column_details import PatchSensitiveColumnDetails
+from .patch_sql_firewall_allowed_sql_details import PatchSqlFirewallAllowedSqlDetails
 from .patch_target_alert_policy_association_details import PatchTargetAlertPolicyAssociationDetails
 from .pattern_format_entry import PatternFormatEntry
 from .peer_target_database import PeerTargetDatabase
@@ -274,6 +278,7 @@ from .sql_expression_format_entry import SQLExpressionFormatEntry
 from .schedule_audit_report_details import ScheduleAuditReportDetails
 from .schedule_report_details import ScheduleReportDetails
 from .schema_summary import SchemaSummary
+from .scim_query_selection_mode import ScimQuerySelectionMode
 from .sdm_masking_policy_difference import SdmMaskingPolicyDifference
 from .sdm_masking_policy_difference_collection import SdmMaskingPolicyDifferenceCollection
 from .sdm_masking_policy_difference_column_collection import SdmMaskingPolicyDifferenceColumnCollection
@@ -302,6 +307,7 @@ from .security_policy_report import SecurityPolicyReport
 from .security_policy_report_collection import SecurityPolicyReportCollection
 from .security_policy_report_summary import SecurityPolicyReportSummary
 from .security_policy_summary import SecurityPolicySummary
+from .selection_details import SelectionDetails
 from .sensitive_category import SensitiveCategory
 from .sensitive_column import SensitiveColumn
 from .sensitive_column_collection import SensitiveColumnCollection
@@ -462,6 +468,8 @@ data_safe_type_mapping = {
     "AutonomousDatabaseDetails": AutonomousDatabaseDetails,
     "AvailableAuditVolumeCollection": AvailableAuditVolumeCollection,
     "AvailableAuditVolumeSummary": AvailableAuditVolumeSummary,
+    "BulkCreateSqlFirewallAllowedSqlsDetails": BulkCreateSqlFirewallAllowedSqlsDetails,
+    "BulkDeleteSqlFirewallAllowedSqlsDetails": BulkDeleteSqlFirewallAllowedSqlsDetails,
     "CalculateAuditVolumeAvailableDetails": CalculateAuditVolumeAvailableDetails,
     "CalculateAuditVolumeCollectedDetails": CalculateAuditVolumeCollectedDetails,
     "ChangeAlertCompartmentDetails": ChangeAlertCompartmentDetails,
@@ -603,6 +611,7 @@ data_safe_type_mapping = {
     "LibraryMaskingFormatCollection": LibraryMaskingFormatCollection,
     "LibraryMaskingFormatEntry": LibraryMaskingFormatEntry,
     "LibraryMaskingFormatSummary": LibraryMaskingFormatSummary,
+    "ListSelectionMode": ListSelectionMode,
     "MaskDataDetails": MaskDataDetails,
     "MaskedColumnCollection": MaskedColumnCollection,
     "MaskedColumnSummary": MaskedColumnSummary,
@@ -645,6 +654,7 @@ data_safe_type_mapping = {
     "PatchRemoveInstruction": PatchRemoveInstruction,
     "PatchSdmMaskingPolicyDifferenceColumnsDetails": PatchSdmMaskingPolicyDifferenceColumnsDetails,
     "PatchSensitiveColumnDetails": PatchSensitiveColumnDetails,
+    "PatchSqlFirewallAllowedSqlDetails": PatchSqlFirewallAllowedSqlDetails,
     "PatchTargetAlertPolicyAssociationDetails": PatchTargetAlertPolicyAssociationDetails,
     "PatternFormatEntry": PatternFormatEntry,
     "PeerTargetDatabase": PeerTargetDatabase,
@@ -683,6 +693,7 @@ data_safe_type_mapping = {
     "ScheduleAuditReportDetails": ScheduleAuditReportDetails,
     "ScheduleReportDetails": ScheduleReportDetails,
     "SchemaSummary": SchemaSummary,
+    "ScimQuerySelectionMode": ScimQuerySelectionMode,
     "SdmMaskingPolicyDifference": SdmMaskingPolicyDifference,
     "SdmMaskingPolicyDifferenceCollection": SdmMaskingPolicyDifferenceCollection,
     "SdmMaskingPolicyDifferenceColumnCollection": SdmMaskingPolicyDifferenceColumnCollection,
@@ -711,6 +722,7 @@ data_safe_type_mapping = {
     "SecurityPolicyReportCollection": SecurityPolicyReportCollection,
     "SecurityPolicyReportSummary": SecurityPolicyReportSummary,
     "SecurityPolicySummary": SecurityPolicySummary,
+    "SelectionDetails": SelectionDetails,
     "SensitiveCategory": SensitiveCategory,
     "SensitiveColumn": SensitiveColumn,
     "SensitiveColumnCollection": SensitiveColumnCollection,

oci/data_safe/models/bulk_create_sql_firewall_allowed_sqls_details.py

@@ -0,0 +1,142 @@
+# coding: utf-8
+# Copyright (c) 2016, 2024, Oracle and/or its affiliates.  All rights reserved.
+# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
+
+# NOTE: This class is auto generated by OracleSDKGenerator. DO NOT EDIT. API Version: 20181201
+
+
+from oci.util import formatted_flat_dict, NONE_SENTINEL, value_allowed_none_or_none_sentinel  # noqa: F401
+from oci.decorators import init_model_state_from_kwargs
+
+
+@init_model_state_from_kwargs
+class BulkCreateSqlFirewallAllowedSqlsDetails(object):
+    """
+    The details used to append the violation logs as allowed SQLs
+    """
+
+    #: A constant which can be used with the log_type property of a BulkCreateSqlFirewallAllowedSqlsDetails.
+    #: This constant has a value of "VIOLATION_LOG"
+    LOG_TYPE_VIOLATION_LOG = "VIOLATION_LOG"
+
+    def __init__(self, **kwargs):
+        """
+        Initializes a new BulkCreateSqlFirewallAllowedSqlsDetails object with values from keyword arguments.
+        The following keyword arguments are supported (corresponding to the getters/setters of this class):
+
+        :param sql_firewall_policy_id:
+            The value to assign to the sql_firewall_policy_id property of this BulkCreateSqlFirewallAllowedSqlsDetails.
+        :type sql_firewall_policy_id: str
+
+        :param log_type:
+            The value to assign to the log_type property of this BulkCreateSqlFirewallAllowedSqlsDetails.
+            Allowed values for this property are: "VIOLATION_LOG"
+        :type log_type: str
+
+        :param selection:
+            The value to assign to the selection property of this BulkCreateSqlFirewallAllowedSqlsDetails.
+        :type selection: oci.data_safe.models.SelectionDetails
+
+        """
+        self.swagger_types = {
+            'sql_firewall_policy_id': 'str',
+            'log_type': 'str',
+            'selection': 'SelectionDetails'
+        }
+
+        self.attribute_map = {
+            'sql_firewall_policy_id': 'sqlFirewallPolicyId',
+            'log_type': 'logType',
+            'selection': 'selection'
+        }
+
+        self._sql_firewall_policy_id = None
+        self._log_type = None
+        self._selection = None
+
+    @property
+    def sql_firewall_policy_id(self):
+        """
+        **[Required]** Gets the sql_firewall_policy_id of this BulkCreateSqlFirewallAllowedSqlsDetails.
+        The OCID of the SQL firewall policy where new allowed SQLs needs to be added.
+
+
+        :return: The sql_firewall_policy_id of this BulkCreateSqlFirewallAllowedSqlsDetails.
+        :rtype: str
+        """
+        return self._sql_firewall_policy_id
+
+    @sql_firewall_policy_id.setter
+    def sql_firewall_policy_id(self, sql_firewall_policy_id):
+        """
+        Sets the sql_firewall_policy_id of this BulkCreateSqlFirewallAllowedSqlsDetails.
+        The OCID of the SQL firewall policy where new allowed SQLs needs to be added.
+
+
+        :param sql_firewall_policy_id: The sql_firewall_policy_id of this BulkCreateSqlFirewallAllowedSqlsDetails.
+        :type: str
+        """
+        self._sql_firewall_policy_id = sql_firewall_policy_id
+
+    @property
+    def log_type(self):
+        """
+        **[Required]** Gets the log_type of this BulkCreateSqlFirewallAllowedSqlsDetails.
+        The type of log to be added as an allowed sql.
+
+        Allowed values for this property are: "VIOLATION_LOG"
+
+
+        :return: The log_type of this BulkCreateSqlFirewallAllowedSqlsDetails.
+        :rtype: str
+        """
+        return self._log_type
+
+    @log_type.setter
+    def log_type(self, log_type):
+        """
+        Sets the log_type of this BulkCreateSqlFirewallAllowedSqlsDetails.
+        The type of log to be added as an allowed sql.
+
+
+        :param log_type: The log_type of this BulkCreateSqlFirewallAllowedSqlsDetails.
+        :type: str
+        """
+        allowed_values = ["VIOLATION_LOG"]
+        if not value_allowed_none_or_none_sentinel(log_type, allowed_values):
+            raise ValueError(
+                f"Invalid value for `log_type`, must be None or one of {allowed_values}"
+            )
+        self._log_type = log_type
+
+    @property
+    def selection(self):
+        """
+        **[Required]** Gets the selection of this BulkCreateSqlFirewallAllowedSqlsDetails.
+
+        :return: The selection of this BulkCreateSqlFirewallAllowedSqlsDetails.
+        :rtype: oci.data_safe.models.SelectionDetails
+        """
+        return self._selection
+
+    @selection.setter
+    def selection(self, selection):
+        """
+        Sets the selection of this BulkCreateSqlFirewallAllowedSqlsDetails.
+
+        :param selection: The selection of this BulkCreateSqlFirewallAllowedSqlsDetails.
+        :type: oci.data_safe.models.SelectionDetails
+        """
+        self._selection = selection
+
+    def __repr__(self):
+        return formatted_flat_dict(self)
+
+    def __eq__(self, other):
+        if other is None:
+            return False
+
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other):
+        return not self == other

oci/data_safe/models/bulk_delete_sql_firewall_allowed_sqls_details.py

@@ -0,0 +1,99 @@
+# coding: utf-8
+# Copyright (c) 2016, 2024, Oracle and/or its affiliates.  All rights reserved.
+# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
+
+# NOTE: This class is auto generated by OracleSDKGenerator. DO NOT EDIT. API Version: 20181201
+
+
+from oci.util import formatted_flat_dict, NONE_SENTINEL, value_allowed_none_or_none_sentinel  # noqa: F401
+from oci.decorators import init_model_state_from_kwargs
+
+
+@init_model_state_from_kwargs
+class BulkDeleteSqlFirewallAllowedSqlsDetails(object):
+    """
+    Details of the allowed SQLs to be deleted from the SQL firewall policy.
+    """
+
+    def __init__(self, **kwargs):
+        """
+        Initializes a new BulkDeleteSqlFirewallAllowedSqlsDetails object with values from keyword arguments.
+        The following keyword arguments are supported (corresponding to the getters/setters of this class):
+
+        :param sql_firewall_policy_id:
+            The value to assign to the sql_firewall_policy_id property of this BulkDeleteSqlFirewallAllowedSqlsDetails.
+        :type sql_firewall_policy_id: str
+
+        :param selection:
+            The value to assign to the selection property of this BulkDeleteSqlFirewallAllowedSqlsDetails.
+        :type selection: oci.data_safe.models.SelectionDetails
+
+        """
+        self.swagger_types = {
+            'sql_firewall_policy_id': 'str',
+            'selection': 'SelectionDetails'
+        }
+
+        self.attribute_map = {
+            'sql_firewall_policy_id': 'sqlFirewallPolicyId',
+            'selection': 'selection'
+        }
+
+        self._sql_firewall_policy_id = None
+        self._selection = None
+
+    @property
+    def sql_firewall_policy_id(self):
+        """
+        **[Required]** Gets the sql_firewall_policy_id of this BulkDeleteSqlFirewallAllowedSqlsDetails.
+        The OCID of the SQL firewall policy whose allowed SQLs needs to be deleted.
+
+
+        :return: The sql_firewall_policy_id of this BulkDeleteSqlFirewallAllowedSqlsDetails.
+        :rtype: str
+        """
+        return self._sql_firewall_policy_id
+
+    @sql_firewall_policy_id.setter
+    def sql_firewall_policy_id(self, sql_firewall_policy_id):
+        """
+        Sets the sql_firewall_policy_id of this BulkDeleteSqlFirewallAllowedSqlsDetails.
+        The OCID of the SQL firewall policy whose allowed SQLs needs to be deleted.
+
+
+        :param sql_firewall_policy_id: The sql_firewall_policy_id of this BulkDeleteSqlFirewallAllowedSqlsDetails.
+        :type: str
+        """
+        self._sql_firewall_policy_id = sql_firewall_policy_id
+
+    @property
+    def selection(self):
+        """
+        **[Required]** Gets the selection of this BulkDeleteSqlFirewallAllowedSqlsDetails.
+
+        :return: The selection of this BulkDeleteSqlFirewallAllowedSqlsDetails.
+        :rtype: oci.data_safe.models.SelectionDetails
+        """
+        return self._selection
+
+    @selection.setter
+    def selection(self, selection):
+        """
+        Sets the selection of this BulkDeleteSqlFirewallAllowedSqlsDetails.
+
+        :param selection: The selection of this BulkDeleteSqlFirewallAllowedSqlsDetails.
+        :type: oci.data_safe.models.SelectionDetails
+        """
+        self._selection = selection
+
+    def __repr__(self):
+        return formatted_flat_dict(self)
+
+    def __eq__(self, other):
+        if other is None:
+            return False
+
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other):
+        return not self == other

oci/data_safe/models/generate_report_details.py

@@ -23,6 +23,10 @@ class GenerateReportDetails(object):
     #: This constant has a value of "XLS"
     MIME_TYPE_XLS = "XLS"
 
+    #: A constant which can be used with the mime_type property of a GenerateReportDetails.
+    #: This constant has a value of "JSON"
+    MIME_TYPE_JSON = "JSON"
+
     def __init__(self, **kwargs):
         """
         Initializes a new GenerateReportDetails object with values from keyword arguments.
@@ -46,7 +50,7 @@ class GenerateReportDetails(object):
 
         :param mime_type:
             The value to assign to the mime_type property of this GenerateReportDetails.
-            Allowed values for this property are: "PDF", "XLS"
+            Allowed values for this property are: "PDF", "XLS", "JSON"
         :type mime_type: str
 
         :param time_less_than:
@@ -201,7 +205,7 @@ class GenerateReportDetails(object):
         **[Required]** Gets the mime_type of this GenerateReportDetails.
         Specifies the format of report to be .xls or .pdf or .json
 
-        Allowed values for this property are: "PDF", "XLS"
+        Allowed values for this property are: "PDF", "XLS", "JSON"
 
 
         :return: The mime_type of this GenerateReportDetails.
@@ -219,7 +223,7 @@ class GenerateReportDetails(object):
         :param mime_type: The mime_type of this GenerateReportDetails.
         :type: str
         """
-        allowed_values = ["PDF", "XLS"]
+        allowed_values = ["PDF", "XLS", "JSON"]
         if not value_allowed_none_or_none_sentinel(mime_type, allowed_values):
             raise ValueError(
                 f"Invalid value for `mime_type`, must be None or one of {allowed_values}"

oci/data_safe/models/list_selection_mode.py

@@ -0,0 +1,84 @@
+# coding: utf-8
+# Copyright (c) 2016, 2024, Oracle and/or its affiliates.  All rights reserved.
+# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
+
+# NOTE: This class is auto generated by OracleSDKGenerator. DO NOT EDIT. API Version: 20181201
+
+from .selection_details import SelectionDetails
+from oci.util import formatted_flat_dict, NONE_SENTINEL, value_allowed_none_or_none_sentinel  # noqa: F401
+from oci.decorators import init_model_state_from_kwargs
+
+
+@init_model_state_from_kwargs
+class ListSelectionMode(SelectionDetails):
+    """
+    Indicates that the selection is a list of resource ocids.
+    """
+
+    def __init__(self, **kwargs):
+        """
+        Initializes a new ListSelectionMode object with values from keyword arguments. The default value of the :py:attr:`~oci.data_safe.models.ListSelectionMode.selection_mode` attribute
+        of this class is ``LIST`` and it should not be changed.
+        The following keyword arguments are supported (corresponding to the getters/setters of this class):
+
+        :param selection_mode:
+            The value to assign to the selection_mode property of this ListSelectionMode.
+            Allowed values for this property are: "LIST", "SCIM_QUERY"
+        :type selection_mode: str
+
+        :param items:
+            The value to assign to the items property of this ListSelectionMode.
+        :type items: list[str]
+
+        """
+        self.swagger_types = {
+            'selection_mode': 'str',
+            'items': 'list[str]'
+        }
+
+        self.attribute_map = {
+            'selection_mode': 'selectionMode',
+            'items': 'items'
+        }
+
+        self._selection_mode = None
+        self._items = None
+        self._selection_mode = 'LIST'
+
+    @property
+    def items(self):
+        """
+        **[Required]** Gets the items of this ListSelectionMode.
+        * Array of the violation log ocids to be selected in case of allowed SQLs bulk create.
+        * Array of the allowed SQL ocids to be selected in case of allowed SQLs bulk delete.
+
+
+        :return: The items of this ListSelectionMode.
+        :rtype: list[str]
+        """
+        return self._items
+
+    @items.setter
+    def items(self, items):
+        """
+        Sets the items of this ListSelectionMode.
+        * Array of the violation log ocids to be selected in case of allowed SQLs bulk create.
+        * Array of the allowed SQL ocids to be selected in case of allowed SQLs bulk delete.
+
+
+        :param items: The items of this ListSelectionMode.
+        :type: list[str]
+        """
+        self._items = items
+
+    def __repr__(self):
+        return formatted_flat_dict(self)
+
+    def __eq__(self, other):
+        if other is None:
+            return False
+
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other):
+        return not self == other