oci 2.126.2__py3-none-any.whl → 2.126.4__py3-none-any.whl

oci/bds/bds_client_composite_operations.py

@@ -364,6 +364,48 @@ class BdsClientCompositeOperations(object):
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
+    def backup_node_and_wait_for_state(self, bds_instance_id, backup_node_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.bds.BdsClient.backup_node` and waits for the :py:class:`~oci.bds.models.WorkRequest`
+        to enter the given state(s).
+
+        :param str bds_instance_id: (required)
+            The OCID of the cluster.
+
+        :param oci.bds.models.BackupNodeDetails backup_node_details: (required)
+            Details for Taking the node's backup
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.bds.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.bds.BdsClient.backup_node`
+
+        :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.backup_node(bds_instance_id, backup_node_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 change_bds_instance_compartment_and_wait_for_state(self, bds_instance_id, change_bds_instance_compartment_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
         Calls :py:func:`~oci.bds.BdsClient.change_bds_instance_compartment` and waits for the :py:class:`~oci.bds.models.WorkRequest`
@@ -571,6 +613,90 @@ class BdsClientCompositeOperations(object):
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
+    def create_node_backup_configuration_and_wait_for_state(self, bds_instance_id, create_node_backup_configuration_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.bds.BdsClient.create_node_backup_configuration` and waits for the :py:class:`~oci.bds.models.WorkRequest`
+        to enter the given state(s).
+
+        :param str bds_instance_id: (required)
+            The OCID of the cluster.
+
+        :param oci.bds.models.CreateNodeBackupConfigurationDetails create_node_backup_configuration_details: (required)
+            Details for adding nodeBackupConfiguration to the BDS cluster.
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.bds.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.bds.BdsClient.create_node_backup_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
+        """
+        operation_result = self.client.create_node_backup_configuration(bds_instance_id, create_node_backup_configuration_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 create_node_replace_configuration_and_wait_for_state(self, bds_instance_id, create_node_replace_configuration_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.bds.BdsClient.create_node_replace_configuration` and waits for the :py:class:`~oci.bds.models.WorkRequest`
+        to enter the given state(s).
+
+        :param str bds_instance_id: (required)
+            The OCID of the cluster.
+
+        :param oci.bds.models.CreateNodeReplaceConfigurationDetails create_node_replace_configuration_details: (required)
+            Details for adding nodeReplaceConfiguration to the BDS cluster.
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.bds.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.bds.BdsClient.create_node_replace_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
+        """
+        operation_result = self.client.create_node_replace_configuration(bds_instance_id, create_node_replace_configuration_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 delete_bds_api_key_and_wait_for_state(self, bds_instance_id, api_key_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
         Calls :py:func:`~oci.bds.BdsClient.delete_bds_api_key` and waits for the :py:class:`~oci.bds.models.WorkRequest`
@@ -718,6 +844,106 @@ class BdsClientCompositeOperations(object):
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
+    def delete_node_backup_and_wait_for_state(self, bds_instance_id, node_backup_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.bds.BdsClient.delete_node_backup` and waits for the :py:class:`~oci.bds.models.WorkRequest`
+        to enter the given state(s).
+
+        :param str bds_instance_id: (required)
+            The OCID of the cluster.
+
+        :param str node_backup_id: (required)
+            Unique assigned identifier of the nodeBackupId.
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.bds.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.bds.BdsClient.delete_node_backup`
+
+        :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_node_backup(bds_instance_id, node_backup_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_node_backup_configuration_and_wait_for_state(self, bds_instance_id, node_backup_configuration_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.bds.BdsClient.delete_node_backup_configuration` and waits for the :py:class:`~oci.bds.models.WorkRequest`
+        to enter the given state(s).
+
+        :param str bds_instance_id: (required)
+            The OCID of the cluster.
+
+        :param str node_backup_configuration_id: (required)
+            Unique Oracle-assigned identifier of the NodeBackupConfiguration.
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.bds.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.bds.BdsClient.delete_node_backup_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
+        """
+        operation_result = None
+        try:
+            operation_result = self.client.delete_node_backup_configuration(bds_instance_id, node_backup_configuration_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 disable_certificate_and_wait_for_state(self, bds_instance_id, disable_certificate_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
         Calls :py:func:`~oci.bds.BdsClient.disable_certificate` and waits for the :py:class:`~oci.bds.models.WorkRequest`
@@ -1099,6 +1325,51 @@ class BdsClientCompositeOperations(object):
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
+    def remove_node_replace_configuration_and_wait_for_state(self, bds_instance_id, node_replace_configuration_id, remove_node_replace_configuration_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.bds.BdsClient.remove_node_replace_configuration` and waits for the :py:class:`~oci.bds.models.WorkRequest`
+        to enter the given state(s).
+
+        :param str bds_instance_id: (required)
+            The OCID of the cluster.
+
+        :param str node_replace_configuration_id: (required)
+            Unique Oracle-assigned identifier of the  NodeReplaceConfiguration.
+
+        :param oci.bds.models.RemoveNodeReplaceConfigurationDetails remove_node_replace_configuration_details: (required)
+            Details for removing NodeReplaceConfiguration
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.bds.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.bds.BdsClient.remove_node_replace_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
+        """
+        operation_result = self.client.remove_node_replace_configuration(bds_instance_id, node_replace_configuration_id, remove_node_replace_configuration_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 renew_certificate_and_wait_for_state(self, bds_instance_id, renew_certificate_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
         Calls :py:func:`~oci.bds.BdsClient.renew_certificate` and waits for the :py:class:`~oci.bds.models.WorkRequest`
@@ -1141,6 +1412,48 @@ class BdsClientCompositeOperations(object):
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
+    def replace_node_and_wait_for_state(self, bds_instance_id, replace_node_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.bds.BdsClient.replace_node` and waits for the :py:class:`~oci.bds.models.WorkRequest`
+        to enter the given state(s).
+
+        :param str bds_instance_id: (required)
+            The OCID of the cluster.
+
+        :param oci.bds.models.ReplaceNodeDetails replace_node_details: (required)
+            Details for Replacing the node.
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.bds.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.bds.BdsClient.replace_node`
+
+        :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.replace_node(bds_instance_id, replace_node_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 restart_node_and_wait_for_state(self, bds_instance_id, restart_node_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
         Calls :py:func:`~oci.bds.BdsClient.restart_node` and waits for the :py:class:`~oci.bds.models.WorkRequest`
@@ -1488,3 +1801,93 @@ class BdsClientCompositeOperations(object):
             return result_to_return
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
+    def update_node_backup_configuration_and_wait_for_state(self, bds_instance_id, node_backup_configuration_id, update_node_backup_configuration_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.bds.BdsClient.update_node_backup_configuration` and waits for the :py:class:`~oci.bds.models.WorkRequest`
+        to enter the given state(s).
+
+        :param str bds_instance_id: (required)
+            The OCID of the cluster.
+
+        :param str node_backup_configuration_id: (required)
+            Unique Oracle-assigned identifier of the NodeBackupConfiguration.
+
+        :param oci.bds.models.UpdateNodeBackupConfigurationDetails update_node_backup_configuration_details: (required)
+            Details for updating the NodeBackupConfiguration.
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.bds.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.bds.BdsClient.update_node_backup_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
+        """
+        operation_result = self.client.update_node_backup_configuration(bds_instance_id, node_backup_configuration_id, update_node_backup_configuration_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 update_node_replace_configuration_and_wait_for_state(self, bds_instance_id, node_replace_configuration_id, update_node_replace_configuration_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.bds.BdsClient.update_node_replace_configuration` and waits for the :py:class:`~oci.bds.models.WorkRequest`
+        to enter the given state(s).
+
+        :param str bds_instance_id: (required)
+            The OCID of the cluster.
+
+        :param str node_replace_configuration_id: (required)
+            Unique Oracle-assigned identifier of the  NodeReplaceConfiguration.
+
+        :param oci.bds.models.UpdateNodeReplaceConfigurationDetails update_node_replace_configuration_details: (required)
+            Details for updating the nodeReplaceConfiguration.
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.bds.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.bds.BdsClient.update_node_replace_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
+        """
+        operation_result = self.client.update_node_replace_configuration(bds_instance_id, node_replace_configuration_id, update_node_replace_configuration_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)

oci/bds/models/__init__.py

@@ -25,6 +25,7 @@ from .auto_scale_policy_metric_rule import AutoScalePolicyMetricRule
 from .auto_scale_policy_rule import AutoScalePolicyRule
 from .auto_scaling_configuration import AutoScalingConfiguration
 from .auto_scaling_configuration_summary import AutoScalingConfigurationSummary
+from .backup_node_details import BackupNodeDetails
 from .batching_based_patching_configs import BatchingBasedPatchingConfigs
 from .bds_api_key import BdsApiKey
 from .bds_api_key_summary import BdsApiKeySummary
@@ -42,7 +43,9 @@ from .cluster_details import ClusterDetails
 from .create_bds_api_key_details import CreateBdsApiKeyDetails
 from .create_bds_instance_details import CreateBdsInstanceDetails
 from .create_bds_metastore_configuration_details import CreateBdsMetastoreConfigurationDetails
+from .create_node_backup_configuration_details import CreateNodeBackupConfigurationDetails
 from .create_node_details import CreateNodeDetails
+from .create_node_replace_configuration_details import CreateNodeReplaceConfigurationDetails
 from .day_based_horizontal_scaling_schedule_details import DayBasedHorizontalScalingScheduleDetails
 from .day_based_vertical_scaling_schedule_details import DayBasedVerticalScalingScheduleDetails
 from .default_error import DefaultError
@@ -56,6 +59,7 @@ from .host_specific_certificate_details import HostSpecificCertificateDetails
 from .install_os_patch_details import InstallOsPatchDetails
 from .install_patch_details import InstallPatchDetails
 from .kerberos_details import KerberosDetails
+from .level_type_details import LevelTypeDetails
 from .metric_based_horizontal_scale_in_config import MetricBasedHorizontalScaleInConfig
 from .metric_based_horizontal_scale_out_config import MetricBasedHorizontalScaleOutConfig
 from .metric_based_horizontal_scaling_policy_details import MetricBasedHorizontalScalingPolicyDetails
@@ -65,6 +69,14 @@ from .metric_based_vertical_scaling_policy_details import MetricBasedVerticalSca
 from .metric_threshold_rule import MetricThresholdRule
 from .network_config import NetworkConfig
 from .node import Node
+from .node_backup import NodeBackup
+from .node_backup_configuration import NodeBackupConfiguration
+from .node_backup_configuration_summary import NodeBackupConfigurationSummary
+from .node_backup_summary import NodeBackupSummary
+from .node_level_details import NodeLevelDetails
+from .node_replace_configuration import NodeReplaceConfiguration
+from .node_replace_configuration_summary import NodeReplaceConfigurationSummary
+from .node_type_level_details import NodeTypeLevelDetails
 from .os_patch_details import OsPatchDetails
 from .os_patch_package_summary import OsPatchPackageSummary
 from .os_patch_summary import OsPatchSummary
@@ -75,7 +87,9 @@ from .remove_auto_scaling_configuration_details import RemoveAutoScalingConfigur
 from .remove_cloud_sql_details import RemoveCloudSqlDetails
 from .remove_kafka_details import RemoveKafkaDetails
 from .remove_node_details import RemoveNodeDetails
+from .remove_node_replace_configuration_details import RemoveNodeReplaceConfigurationDetails
 from .renew_certificate_details import RenewCertificateDetails
+from .replace_node_details import ReplaceNodeDetails
 from .restart_node_details import RestartNodeDetails
 from .schedule_based_horizontal_scaling_policy_details import ScheduleBasedHorizontalScalingPolicyDetails
 from .schedule_based_vertical_scaling_policy_details import ScheduleBasedVerticalScalingPolicyDetails
@@ -92,6 +106,8 @@ from .update_bds_instance_details import UpdateBdsInstanceDetails
 from .update_bds_metastore_configuration_details import UpdateBdsMetastoreConfigurationDetails
 from .update_metric_based_horizontal_scaling_policy_details import UpdateMetricBasedHorizontalScalingPolicyDetails
 from .update_metric_based_vertical_scaling_policy_details import UpdateMetricBasedVerticalScalingPolicyDetails
+from .update_node_backup_configuration_details import UpdateNodeBackupConfigurationDetails
+from .update_node_replace_configuration_details import UpdateNodeReplaceConfigurationDetails
 from .update_schedule_based_horizontal_scaling_policy_details import UpdateScheduleBasedHorizontalScalingPolicyDetails
 from .update_schedule_based_vertical_scaling_policy_details import UpdateScheduleBasedVerticalScalingPolicyDetails
 from .vertical_scaling_schedule_details import VerticalScalingScheduleDetails
@@ -122,6 +138,7 @@ bds_type_mapping = {
     "AutoScalePolicyRule": AutoScalePolicyRule,
     "AutoScalingConfiguration": AutoScalingConfiguration,
     "AutoScalingConfigurationSummary": AutoScalingConfigurationSummary,
+    "BackupNodeDetails": BackupNodeDetails,
     "BatchingBasedPatchingConfigs": BatchingBasedPatchingConfigs,
     "BdsApiKey": BdsApiKey,
     "BdsApiKeySummary": BdsApiKeySummary,
@@ -139,7 +156,9 @@ bds_type_mapping = {
     "CreateBdsApiKeyDetails": CreateBdsApiKeyDetails,
     "CreateBdsInstanceDetails": CreateBdsInstanceDetails,
     "CreateBdsMetastoreConfigurationDetails": CreateBdsMetastoreConfigurationDetails,
+    "CreateNodeBackupConfigurationDetails": CreateNodeBackupConfigurationDetails,
     "CreateNodeDetails": CreateNodeDetails,
+    "CreateNodeReplaceConfigurationDetails": CreateNodeReplaceConfigurationDetails,
     "DayBasedHorizontalScalingScheduleDetails": DayBasedHorizontalScalingScheduleDetails,
     "DayBasedVerticalScalingScheduleDetails": DayBasedVerticalScalingScheduleDetails,
     "DefaultError": DefaultError,
@@ -153,6 +172,7 @@ bds_type_mapping = {
     "InstallOsPatchDetails": InstallOsPatchDetails,
     "InstallPatchDetails": InstallPatchDetails,
     "KerberosDetails": KerberosDetails,
+    "LevelTypeDetails": LevelTypeDetails,
     "MetricBasedHorizontalScaleInConfig": MetricBasedHorizontalScaleInConfig,
     "MetricBasedHorizontalScaleOutConfig": MetricBasedHorizontalScaleOutConfig,
     "MetricBasedHorizontalScalingPolicyDetails": MetricBasedHorizontalScalingPolicyDetails,
@@ -162,6 +182,14 @@ bds_type_mapping = {
     "MetricThresholdRule": MetricThresholdRule,
     "NetworkConfig": NetworkConfig,
     "Node": Node,
+    "NodeBackup": NodeBackup,
+    "NodeBackupConfiguration": NodeBackupConfiguration,
+    "NodeBackupConfigurationSummary": NodeBackupConfigurationSummary,
+    "NodeBackupSummary": NodeBackupSummary,
+    "NodeLevelDetails": NodeLevelDetails,
+    "NodeReplaceConfiguration": NodeReplaceConfiguration,
+    "NodeReplaceConfigurationSummary": NodeReplaceConfigurationSummary,
+    "NodeTypeLevelDetails": NodeTypeLevelDetails,
     "OsPatchDetails": OsPatchDetails,
     "OsPatchPackageSummary": OsPatchPackageSummary,
     "OsPatchSummary": OsPatchSummary,
@@ -172,7 +200,9 @@ bds_type_mapping = {
     "RemoveCloudSqlDetails": RemoveCloudSqlDetails,
     "RemoveKafkaDetails": RemoveKafkaDetails,
     "RemoveNodeDetails": RemoveNodeDetails,
+    "RemoveNodeReplaceConfigurationDetails": RemoveNodeReplaceConfigurationDetails,
     "RenewCertificateDetails": RenewCertificateDetails,
+    "ReplaceNodeDetails": ReplaceNodeDetails,
     "RestartNodeDetails": RestartNodeDetails,
     "ScheduleBasedHorizontalScalingPolicyDetails": ScheduleBasedHorizontalScalingPolicyDetails,
     "ScheduleBasedVerticalScalingPolicyDetails": ScheduleBasedVerticalScalingPolicyDetails,
@@ -189,6 +219,8 @@ bds_type_mapping = {
     "UpdateBdsMetastoreConfigurationDetails": UpdateBdsMetastoreConfigurationDetails,
     "UpdateMetricBasedHorizontalScalingPolicyDetails": UpdateMetricBasedHorizontalScalingPolicyDetails,
     "UpdateMetricBasedVerticalScalingPolicyDetails": UpdateMetricBasedVerticalScalingPolicyDetails,
+    "UpdateNodeBackupConfigurationDetails": UpdateNodeBackupConfigurationDetails,
+    "UpdateNodeReplaceConfigurationDetails": UpdateNodeReplaceConfigurationDetails,
     "UpdateScheduleBasedHorizontalScalingPolicyDetails": UpdateScheduleBasedHorizontalScalingPolicyDetails,
     "UpdateScheduleBasedVerticalScalingPolicyDetails": UpdateScheduleBasedVerticalScalingPolicyDetails,
     "VerticalScalingScheduleDetails": VerticalScalingScheduleDetails,

oci/bds/models/backup_node_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: 20190531
+
+
+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 BackupNodeDetails(object):
+    """
+    The information about the nodes to backup.
+    """
+
+    def __init__(self, **kwargs):
+        """
+        Initializes a new BackupNodeDetails object with values from keyword arguments.
+        The following keyword arguments are supported (corresponding to the getters/setters of this class):
+
+        :param level_type_details:
+            The value to assign to the level_type_details property of this BackupNodeDetails.
+        :type level_type_details: oci.bds.models.LevelTypeDetails
+
+        :param backup_type:
+            The value to assign to the backup_type property of this BackupNodeDetails.
+        :type backup_type: str
+
+        """
+        self.swagger_types = {
+            'level_type_details': 'LevelTypeDetails',
+            'backup_type': 'str'
+        }
+
+        self.attribute_map = {
+            'level_type_details': 'levelTypeDetails',
+            'backup_type': 'backupType'
+        }
+
+        self._level_type_details = None
+        self._backup_type = None
+
+    @property
+    def level_type_details(self):
+        """
+        **[Required]** Gets the level_type_details of this BackupNodeDetails.
+
+        :return: The level_type_details of this BackupNodeDetails.
+        :rtype: oci.bds.models.LevelTypeDetails
+        """
+        return self._level_type_details
+
+    @level_type_details.setter
+    def level_type_details(self, level_type_details):
+        """
+        Sets the level_type_details of this BackupNodeDetails.
+
+        :param level_type_details: The level_type_details of this BackupNodeDetails.
+        :type: oci.bds.models.LevelTypeDetails
+        """
+        self._level_type_details = level_type_details
+
+    @property
+    def backup_type(self):
+        """
+        Gets the backup_type of this BackupNodeDetails.
+        Incremental backup type includes only the changes since the last backup. Full backup type includes all changes since the volume was created.
+
+
+        :return: The backup_type of this BackupNodeDetails.
+        :rtype: str
+        """
+        return self._backup_type
+
+    @backup_type.setter
+    def backup_type(self, backup_type):
+        """
+        Sets the backup_type of this BackupNodeDetails.
+        Incremental backup type includes only the changes since the last backup. Full backup type includes all changes since the volume was created.
+
+
+        :param backup_type: The backup_type of this BackupNodeDetails.
+        :type: str
+        """
+        self._backup_type = backup_type
+
+    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