pulumi-oci 2.25.0a1740032973__py3-none-any.whl → 2.26.0__py3-none-any.whl

pulumi_oci/database/outputs.py

@@ -16,8 +16,10 @@ from .. import _utilities
 from . import outputs
 
 __all__ = [
+    'AutonomousContainerDatabaseAssociatedBackupConfigurationDetail',
     'AutonomousContainerDatabaseBackupConfig',
     'AutonomousContainerDatabaseBackupConfigBackupDestinationDetails',
+    'AutonomousContainerDatabaseBackupDestinationPropertiesList',
     'AutonomousContainerDatabaseDataguardAssociationPeerAutonomousContainerDatabaseBackupConfig',
     'AutonomousContainerDatabaseDataguardAssociationPeerAutonomousContainerDatabaseBackupConfigBackupDestinationDetail',
     'AutonomousContainerDatabaseKeyHistoryEntry',
@@ -29,6 +31,7 @@ __all__ = [
     'AutonomousContainerDatabaseMaintenanceWindowMonth',
     'AutonomousContainerDatabasePeerAutonomousContainerDatabaseBackupConfig',
     'AutonomousContainerDatabasePeerAutonomousContainerDatabaseBackupConfigBackupDestinationDetail',
+    'AutonomousContainerDatabaseRecoveryApplianceDetail',
     'AutonomousDatabaseApexDetail',
     'AutonomousDatabaseBackupBackupDestinationDetails',
     'AutonomousDatabaseBackupConfig',
@@ -132,8 +135,16 @@ __all__ = [
     'ExadataInfrastructureComputeMaintenanceWindow',
     'ExadataInfrastructureComputeMaintenanceWindowDaysOfWeek',
     'ExadataInfrastructureComputeMaintenanceWindowMonth',
+    'ExadataInfrastructureConfigureExascaleManagementContact',
+    'ExadataInfrastructureConfigureExascaleManagementDefinedFileSystemConfiguration',
+    'ExadataInfrastructureConfigureExascaleManagementExascaleConfig',
+    'ExadataInfrastructureConfigureExascaleManagementMaintenanceWindow',
+    'ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowDaysOfWeek',
+    'ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowMonth',
+    'ExadataInfrastructureConfigureExascaleManagementNetworkBondingModeDetail',
     'ExadataInfrastructureContact',
     'ExadataInfrastructureDefinedFileSystemConfiguration',
+    'ExadataInfrastructureExascaleConfig',
     'ExadataInfrastructureMaintenanceWindow',
     'ExadataInfrastructureMaintenanceWindowDaysOfWeek',
     'ExadataInfrastructureMaintenanceWindowMonth',
@@ -210,8 +221,10 @@ __all__ = [
     'GetApplicationVipsFilterResult',
     'GetAutonomousCharacterSetsAutonomousDatabaseCharacterSetResult',
     'GetAutonomousCharacterSetsFilterResult',
+    'GetAutonomousContainerDatabaseAssociatedBackupConfigurationDetailResult',
     'GetAutonomousContainerDatabaseBackupConfigResult',
     'GetAutonomousContainerDatabaseBackupConfigBackupDestinationDetailResult',
+    'GetAutonomousContainerDatabaseBackupDestinationPropertiesListResult',
     'GetAutonomousContainerDatabaseDataguardAssociationPeerAutonomousContainerDatabaseBackupConfigResult',
     'GetAutonomousContainerDatabaseDataguardAssociationPeerAutonomousContainerDatabaseBackupConfigBackupDestinationDetailResult',
     'GetAutonomousContainerDatabaseDataguardAssociationsAutonomousContainerDatabaseDataguardAssociationResult',
@@ -227,13 +240,16 @@ __all__ = [
     'GetAutonomousContainerDatabaseMaintenanceWindowMonthResult',
     'GetAutonomousContainerDatabasePeerAutonomousContainerDatabaseBackupConfigResult',
     'GetAutonomousContainerDatabasePeerAutonomousContainerDatabaseBackupConfigBackupDestinationDetailResult',
+    'GetAutonomousContainerDatabaseRecoveryApplianceDetailResult',
     'GetAutonomousContainerDatabaseResourceUsageAutonomousContainerDatabaseVmUsageResult',
     'GetAutonomousContainerDatabaseVersionsAutonomousContainerDatabaseVersionResult',
     'GetAutonomousContainerDatabaseVersionsAutonomousContainerDatabaseVersionSupportedAppResult',
     'GetAutonomousContainerDatabaseVersionsFilterResult',
     'GetAutonomousContainerDatabasesAutonomousContainerDatabaseResult',
+    'GetAutonomousContainerDatabasesAutonomousContainerDatabaseAssociatedBackupConfigurationDetailResult',
     'GetAutonomousContainerDatabasesAutonomousContainerDatabaseBackupConfigResult',
     'GetAutonomousContainerDatabasesAutonomousContainerDatabaseBackupConfigBackupDestinationDetailResult',
+    'GetAutonomousContainerDatabasesAutonomousContainerDatabaseBackupDestinationPropertiesListResult',
     'GetAutonomousContainerDatabasesAutonomousContainerDatabaseKeyHistoryEntryResult',
     'GetAutonomousContainerDatabasesAutonomousContainerDatabaseMaintenanceWindowResult',
     'GetAutonomousContainerDatabasesAutonomousContainerDatabaseMaintenanceWindowDaysOfWeekResult',
@@ -243,6 +259,7 @@ __all__ = [
     'GetAutonomousContainerDatabasesAutonomousContainerDatabaseMaintenanceWindowMonthResult',
     'GetAutonomousContainerDatabasesAutonomousContainerDatabasePeerAutonomousContainerDatabaseBackupConfigResult',
     'GetAutonomousContainerDatabasesAutonomousContainerDatabasePeerAutonomousContainerDatabaseBackupConfigBackupDestinationDetailResult',
+    'GetAutonomousContainerDatabasesAutonomousContainerDatabaseRecoveryApplianceDetailResult',
     'GetAutonomousContainerDatabasesFilterResult',
     'GetAutonomousContainerPatchesAutonomousPatchResult',
     'GetAutonomousContainerPatchesFilterResult',
@@ -541,6 +558,7 @@ __all__ = [
     'GetDbVersionsFilterResult',
     'GetExadataInfrastructureContactResult',
     'GetExadataInfrastructureDefinedFileSystemConfigurationResult',
+    'GetExadataInfrastructureExascaleConfigResult',
     'GetExadataInfrastructureMaintenanceWindowResult',
     'GetExadataInfrastructureMaintenanceWindowDaysOfWeekResult',
     'GetExadataInfrastructureMaintenanceWindowMonthResult',
@@ -549,6 +567,7 @@ __all__ = [
     'GetExadataInfrastructuresExadataInfrastructureResult',
     'GetExadataInfrastructuresExadataInfrastructureContactResult',
     'GetExadataInfrastructuresExadataInfrastructureDefinedFileSystemConfigurationResult',
+    'GetExadataInfrastructuresExadataInfrastructureExascaleConfigResult',
     'GetExadataInfrastructuresExadataInfrastructureMaintenanceWindowResult',
     'GetExadataInfrastructuresExadataInfrastructureMaintenanceWindowDaysOfWeekResult',
     'GetExadataInfrastructuresExadataInfrastructureMaintenanceWindowMonthResult',
@@ -712,6 +731,164 @@ __all__ = [
     'GetVmClustersVmClusterFileSystemConfigurationDetailResult',
 ]
 
+@pulumi.output_type
+class AutonomousContainerDatabaseAssociatedBackupConfigurationDetail(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "backupDestinationAttachHistories":
+            suggest = "backup_destination_attach_histories"
+        elif key == "dbrsPolicyId":
+            suggest = "dbrs_policy_id"
+        elif key == "internetProxy":
+            suggest = "internet_proxy"
+        elif key == "recoveryWindowInDays":
+            suggest = "recovery_window_in_days"
+        elif key == "spaceUtilizedInGbs":
+            suggest = "space_utilized_in_gbs"
+        elif key == "timeAtWhichStorageDetailsAreUpdated":
+            suggest = "time_at_which_storage_details_are_updated"
+        elif key == "vpcPassword":
+            suggest = "vpc_password"
+        elif key == "vpcUser":
+            suggest = "vpc_user"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AutonomousContainerDatabaseAssociatedBackupConfigurationDetail. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AutonomousContainerDatabaseAssociatedBackupConfigurationDetail.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AutonomousContainerDatabaseAssociatedBackupConfigurationDetail.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 backup_destination_attach_histories: Optional[Sequence[str]] = None,
+                 dbrs_policy_id: Optional[str] = None,
+                 id: Optional[str] = None,
+                 internet_proxy: Optional[str] = None,
+                 recovery_window_in_days: Optional[int] = None,
+                 space_utilized_in_gbs: Optional[int] = None,
+                 time_at_which_storage_details_are_updated: Optional[str] = None,
+                 type: Optional[str] = None,
+                 vpc_password: Optional[str] = None,
+                 vpc_user: Optional[str] = None):
+        """
+        :param Sequence[str] backup_destination_attach_histories: The timestamps at which this backup destination is used as the preferred destination to host the Autonomous Container Database backups.
+        :param str dbrs_policy_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the DBRS policy used for backup.
+        :param str id: The id of the Autonomous Database [Vault](https://docs.cloud.oracle.com/iaas/Content/KeyManagement/Concepts/keyoverview.htm#concepts) service key management history entry.
+        :param str internet_proxy: Proxy URL to connect to object store.
+        :param int recovery_window_in_days: Number of days between the current and earliest point of recoverability covered by automatic backups.
+        :param int space_utilized_in_gbs: The total space utilized (in GBs) by this Autonomous Container Database on this backup destination, rounded to the nearest integer.
+        :param str time_at_which_storage_details_are_updated: The latest timestamp when the backup destination details, such as 'spaceUtilized,' are updated.
+        :param str type: Type of the database backup destination.
+        :param str vpc_password: For a RECOVERY_APPLIANCE backup destination, the password for the VPC user that is used to access the Recovery Appliance.
+        :param str vpc_user: For a RECOVERY_APPLIANCE backup destination, the Virtual Private Catalog (VPC) user that is used to access the Recovery Appliance.
+        """
+        if backup_destination_attach_histories is not None:
+            pulumi.set(__self__, "backup_destination_attach_histories", backup_destination_attach_histories)
+        if dbrs_policy_id is not None:
+            pulumi.set(__self__, "dbrs_policy_id", dbrs_policy_id)
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+        if internet_proxy is not None:
+            pulumi.set(__self__, "internet_proxy", internet_proxy)
+        if recovery_window_in_days is not None:
+            pulumi.set(__self__, "recovery_window_in_days", recovery_window_in_days)
+        if space_utilized_in_gbs is not None:
+            pulumi.set(__self__, "space_utilized_in_gbs", space_utilized_in_gbs)
+        if time_at_which_storage_details_are_updated is not None:
+            pulumi.set(__self__, "time_at_which_storage_details_are_updated", time_at_which_storage_details_are_updated)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+        if vpc_password is not None:
+            pulumi.set(__self__, "vpc_password", vpc_password)
+        if vpc_user is not None:
+            pulumi.set(__self__, "vpc_user", vpc_user)
+
+    @property
+    @pulumi.getter(name="backupDestinationAttachHistories")
+    def backup_destination_attach_histories(self) -> Optional[Sequence[str]]:
+        """
+        The timestamps at which this backup destination is used as the preferred destination to host the Autonomous Container Database backups.
+        """
+        return pulumi.get(self, "backup_destination_attach_histories")
+
+    @property
+    @pulumi.getter(name="dbrsPolicyId")
+    def dbrs_policy_id(self) -> Optional[str]:
+        """
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the DBRS policy used for backup.
+        """
+        return pulumi.get(self, "dbrs_policy_id")
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[str]:
+        """
+        The id of the Autonomous Database [Vault](https://docs.cloud.oracle.com/iaas/Content/KeyManagement/Concepts/keyoverview.htm#concepts) service key management history entry.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="internetProxy")
+    def internet_proxy(self) -> Optional[str]:
+        """
+        Proxy URL to connect to object store.
+        """
+        return pulumi.get(self, "internet_proxy")
+
+    @property
+    @pulumi.getter(name="recoveryWindowInDays")
+    def recovery_window_in_days(self) -> Optional[int]:
+        """
+        Number of days between the current and earliest point of recoverability covered by automatic backups.
+        """
+        return pulumi.get(self, "recovery_window_in_days")
+
+    @property
+    @pulumi.getter(name="spaceUtilizedInGbs")
+    def space_utilized_in_gbs(self) -> Optional[int]:
+        """
+        The total space utilized (in GBs) by this Autonomous Container Database on this backup destination, rounded to the nearest integer.
+        """
+        return pulumi.get(self, "space_utilized_in_gbs")
+
+    @property
+    @pulumi.getter(name="timeAtWhichStorageDetailsAreUpdated")
+    def time_at_which_storage_details_are_updated(self) -> Optional[str]:
+        """
+        The latest timestamp when the backup destination details, such as 'spaceUtilized,' are updated.
+        """
+        return pulumi.get(self, "time_at_which_storage_details_are_updated")
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[str]:
+        """
+        Type of the database backup destination.
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter(name="vpcPassword")
+    def vpc_password(self) -> Optional[str]:
+        """
+        For a RECOVERY_APPLIANCE backup destination, the password for the VPC user that is used to access the Recovery Appliance.
+        """
+        return pulumi.get(self, "vpc_password")
+
+    @property
+    @pulumi.getter(name="vpcUser")
+    def vpc_user(self) -> Optional[str]:
+        """
+        For a RECOVERY_APPLIANCE backup destination, the Virtual Private Catalog (VPC) user that is used to access the Recovery Appliance.
+        """
+        return pulumi.get(self, "vpc_user")
+
+
 @pulumi.output_type
 class AutonomousContainerDatabaseBackupConfig(dict):
     @staticmethod
@@ -849,6 +1026,70 @@ class AutonomousContainerDatabaseBackupConfigBackupDestinationDetails(dict):
         return pulumi.get(self, "vpc_user")
 
 
+@pulumi.output_type
+class AutonomousContainerDatabaseBackupDestinationPropertiesList(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "backupDestinationAttachHistories":
+            suggest = "backup_destination_attach_histories"
+        elif key == "spaceUtilizedInGbs":
+            suggest = "space_utilized_in_gbs"
+        elif key == "timeAtWhichStorageDetailsAreUpdated":
+            suggest = "time_at_which_storage_details_are_updated"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AutonomousContainerDatabaseBackupDestinationPropertiesList. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AutonomousContainerDatabaseBackupDestinationPropertiesList.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AutonomousContainerDatabaseBackupDestinationPropertiesList.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 backup_destination_attach_histories: Optional[Sequence[str]] = None,
+                 space_utilized_in_gbs: Optional[int] = None,
+                 time_at_which_storage_details_are_updated: Optional[str] = None):
+        """
+        :param Sequence[str] backup_destination_attach_histories: The timestamps at which this backup destination is used as the preferred destination to host the Autonomous Container Database backups.
+        :param int space_utilized_in_gbs: The total space utilized (in GBs) by this Autonomous Container Database on this backup destination, rounded to the nearest integer.
+        :param str time_at_which_storage_details_are_updated: The latest timestamp when the backup destination details, such as 'spaceUtilized,' are updated.
+        """
+        if backup_destination_attach_histories is not None:
+            pulumi.set(__self__, "backup_destination_attach_histories", backup_destination_attach_histories)
+        if space_utilized_in_gbs is not None:
+            pulumi.set(__self__, "space_utilized_in_gbs", space_utilized_in_gbs)
+        if time_at_which_storage_details_are_updated is not None:
+            pulumi.set(__self__, "time_at_which_storage_details_are_updated", time_at_which_storage_details_are_updated)
+
+    @property
+    @pulumi.getter(name="backupDestinationAttachHistories")
+    def backup_destination_attach_histories(self) -> Optional[Sequence[str]]:
+        """
+        The timestamps at which this backup destination is used as the preferred destination to host the Autonomous Container Database backups.
+        """
+        return pulumi.get(self, "backup_destination_attach_histories")
+
+    @property
+    @pulumi.getter(name="spaceUtilizedInGbs")
+    def space_utilized_in_gbs(self) -> Optional[int]:
+        """
+        The total space utilized (in GBs) by this Autonomous Container Database on this backup destination, rounded to the nearest integer.
+        """
+        return pulumi.get(self, "space_utilized_in_gbs")
+
+    @property
+    @pulumi.getter(name="timeAtWhichStorageDetailsAreUpdated")
+    def time_at_which_storage_details_are_updated(self) -> Optional[str]:
+        """
+        The latest timestamp when the backup destination details, such as 'spaceUtilized,' are updated.
+        """
+        return pulumi.get(self, "time_at_which_storage_details_are_updated")
+
+
 @pulumi.output_type
 class AutonomousContainerDatabaseDataguardAssociationPeerAutonomousContainerDatabaseBackupConfig(dict):
     @staticmethod
@@ -1639,6 +1880,72 @@ class AutonomousContainerDatabasePeerAutonomousContainerDatabaseBackupConfigBack
         return pulumi.get(self, "vpc_user")
 
 
+@pulumi.output_type
+class AutonomousContainerDatabaseRecoveryApplianceDetail(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "allocatedStorageSizeInGbs":
+            suggest = "allocated_storage_size_in_gbs"
+        elif key == "recoveryWindowInDays":
+            suggest = "recovery_window_in_days"
+        elif key == "timeRecoveryApplianceDetailsUpdated":
+            suggest = "time_recovery_appliance_details_updated"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AutonomousContainerDatabaseRecoveryApplianceDetail. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AutonomousContainerDatabaseRecoveryApplianceDetail.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AutonomousContainerDatabaseRecoveryApplianceDetail.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 allocated_storage_size_in_gbs: Optional[int] = None,
+                 recovery_window_in_days: Optional[int] = None,
+                 time_recovery_appliance_details_updated: Optional[str] = None):
+        """
+        :param int allocated_storage_size_in_gbs: The storage size of the backup destination allocated for an Autonomous Container Database to store backups on the recovery appliance, in GBs, rounded to the nearest integer.
+        :param int recovery_window_in_days: Number of days between the current and earliest point of recoverability covered by automatic backups.
+        :param str time_recovery_appliance_details_updated: The time when the recovery appliance details are updated.
+               =======
+        """
+        if allocated_storage_size_in_gbs is not None:
+            pulumi.set(__self__, "allocated_storage_size_in_gbs", allocated_storage_size_in_gbs)
+        if recovery_window_in_days is not None:
+            pulumi.set(__self__, "recovery_window_in_days", recovery_window_in_days)
+        if time_recovery_appliance_details_updated is not None:
+            pulumi.set(__self__, "time_recovery_appliance_details_updated", time_recovery_appliance_details_updated)
+
+    @property
+    @pulumi.getter(name="allocatedStorageSizeInGbs")
+    def allocated_storage_size_in_gbs(self) -> Optional[int]:
+        """
+        The storage size of the backup destination allocated for an Autonomous Container Database to store backups on the recovery appliance, in GBs, rounded to the nearest integer.
+        """
+        return pulumi.get(self, "allocated_storage_size_in_gbs")
+
+    @property
+    @pulumi.getter(name="recoveryWindowInDays")
+    def recovery_window_in_days(self) -> Optional[int]:
+        """
+        Number of days between the current and earliest point of recoverability covered by automatic backups.
+        """
+        return pulumi.get(self, "recovery_window_in_days")
+
+    @property
+    @pulumi.getter(name="timeRecoveryApplianceDetailsUpdated")
+    def time_recovery_appliance_details_updated(self) -> Optional[str]:
+        """
+        The time when the recovery appliance details are updated.
+        =======
+        """
+        return pulumi.get(self, "time_recovery_appliance_details_updated")
+
+
 @pulumi.output_type
 class AutonomousDatabaseApexDetail(dict):
     @staticmethod
@@ -2867,10 +3174,16 @@ class AutonomousDatabaseLocalStandbyDb(dict):
             suggest = "lag_time_in_seconds"
         elif key == "lifecycleDetails":
             suggest = "lifecycle_details"
+        elif key == "maintenanceTargetComponent":
+            suggest = "maintenance_target_component"
         elif key == "timeDataGuardRoleChanged":
             suggest = "time_data_guard_role_changed"
         elif key == "timeDisasterRecoveryRoleChanged":
             suggest = "time_disaster_recovery_role_changed"
+        elif key == "timeMaintenanceBegin":
+            suggest = "time_maintenance_begin"
+        elif key == "timeMaintenanceEnd":
+            suggest = "time_maintenance_end"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in AutonomousDatabaseLocalStandbyDb. Access the value via the '{suggest}' property getter instead.")
@@ -2887,16 +3200,22 @@ class AutonomousDatabaseLocalStandbyDb(dict):
                  availability_domain: Optional[str] = None,
                  lag_time_in_seconds: Optional[int] = None,
                  lifecycle_details: Optional[str] = None,
+                 maintenance_target_component: Optional[str] = None,
                  state: Optional[str] = None,
                  time_data_guard_role_changed: Optional[str] = None,
-                 time_disaster_recovery_role_changed: Optional[str] = None):
+                 time_disaster_recovery_role_changed: Optional[str] = None,
+                 time_maintenance_begin: Optional[str] = None,
+                 time_maintenance_end: Optional[str] = None):
         """
         :param str availability_domain: The availability domain of a local Autonomous Data Guard standby database of an Autonomous Database Serverless instance.
         :param int lag_time_in_seconds: The amount of time, in seconds, that the data of the standby database lags the data of the primary database. Can be used to determine the potential data loss in the event of a failover.
         :param str lifecycle_details: Additional information about the current lifecycle state.
+        :param str maintenance_target_component: The component chosen for maintenance.
         :param str state: The current state of the Autonomous Database.
         :param str time_data_guard_role_changed: The date and time the Autonomous Data Guard role was switched for the Autonomous Database. For databases that have standbys in both the primary Data Guard region and a remote Data Guard standby region, this is the latest timestamp of either the database using the "primary" role in the primary Data Guard region, or database located in the remote Data Guard standby region.
         :param str time_disaster_recovery_role_changed: The date and time the Disaster Recovery role was switched for the standby Autonomous Database.
+        :param str time_maintenance_begin: The date and time when maintenance will begin.
+        :param str time_maintenance_end: The date and time when maintenance will end.
         """
         if availability_domain is not None:
             pulumi.set(__self__, "availability_domain", availability_domain)
@@ -2904,12 +3223,18 @@ class AutonomousDatabaseLocalStandbyDb(dict):
             pulumi.set(__self__, "lag_time_in_seconds", lag_time_in_seconds)
         if lifecycle_details is not None:
             pulumi.set(__self__, "lifecycle_details", lifecycle_details)
+        if maintenance_target_component is not None:
+            pulumi.set(__self__, "maintenance_target_component", maintenance_target_component)
         if state is not None:
             pulumi.set(__self__, "state", state)
         if time_data_guard_role_changed is not None:
             pulumi.set(__self__, "time_data_guard_role_changed", time_data_guard_role_changed)
         if time_disaster_recovery_role_changed is not None:
             pulumi.set(__self__, "time_disaster_recovery_role_changed", time_disaster_recovery_role_changed)
+        if time_maintenance_begin is not None:
+            pulumi.set(__self__, "time_maintenance_begin", time_maintenance_begin)
+        if time_maintenance_end is not None:
+            pulumi.set(__self__, "time_maintenance_end", time_maintenance_end)
 
     @property
     @pulumi.getter(name="availabilityDomain")
@@ -2935,6 +3260,14 @@ class AutonomousDatabaseLocalStandbyDb(dict):
         """
         return pulumi.get(self, "lifecycle_details")
 
+    @property
+    @pulumi.getter(name="maintenanceTargetComponent")
+    def maintenance_target_component(self) -> Optional[str]:
+        """
+        The component chosen for maintenance.
+        """
+        return pulumi.get(self, "maintenance_target_component")
+
     @property
     @pulumi.getter
     def state(self) -> Optional[str]:
@@ -2959,6 +3292,22 @@ class AutonomousDatabaseLocalStandbyDb(dict):
         """
         return pulumi.get(self, "time_disaster_recovery_role_changed")
 
+    @property
+    @pulumi.getter(name="timeMaintenanceBegin")
+    def time_maintenance_begin(self) -> Optional[str]:
+        """
+        The date and time when maintenance will begin.
+        """
+        return pulumi.get(self, "time_maintenance_begin")
+
+    @property
+    @pulumi.getter(name="timeMaintenanceEnd")
+    def time_maintenance_end(self) -> Optional[str]:
+        """
+        The date and time when maintenance will end.
+        """
+        return pulumi.get(self, "time_maintenance_end")
+
 
 @pulumi.output_type
 class AutonomousDatabaseLongTermBackupSchedule(dict):
@@ -3392,10 +3741,16 @@ class AutonomousDatabaseStandbyDb(dict):
             suggest = "lag_time_in_seconds"
         elif key == "lifecycleDetails":
             suggest = "lifecycle_details"
+        elif key == "maintenanceTargetComponent":
+            suggest = "maintenance_target_component"
         elif key == "timeDataGuardRoleChanged":
             suggest = "time_data_guard_role_changed"
         elif key == "timeDisasterRecoveryRoleChanged":
             suggest = "time_disaster_recovery_role_changed"
+        elif key == "timeMaintenanceBegin":
+            suggest = "time_maintenance_begin"
+        elif key == "timeMaintenanceEnd":
+            suggest = "time_maintenance_end"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in AutonomousDatabaseStandbyDb. Access the value via the '{suggest}' property getter instead.")
@@ -3412,16 +3767,22 @@ class AutonomousDatabaseStandbyDb(dict):
                  availability_domain: Optional[str] = None,
                  lag_time_in_seconds: Optional[int] = None,
                  lifecycle_details: Optional[str] = None,
+                 maintenance_target_component: Optional[str] = None,
                  state: Optional[str] = None,
                  time_data_guard_role_changed: Optional[str] = None,
-                 time_disaster_recovery_role_changed: Optional[str] = None):
+                 time_disaster_recovery_role_changed: Optional[str] = None,
+                 time_maintenance_begin: Optional[str] = None,
+                 time_maintenance_end: Optional[str] = None):
         """
         :param str availability_domain: The availability domain of a local Autonomous Data Guard standby database of an Autonomous Database Serverless instance.
         :param int lag_time_in_seconds: The amount of time, in seconds, that the data of the standby database lags the data of the primary database. Can be used to determine the potential data loss in the event of a failover.
         :param str lifecycle_details: Additional information about the current lifecycle state.
+        :param str maintenance_target_component: The component chosen for maintenance.
         :param str state: The current state of the Autonomous Database.
         :param str time_data_guard_role_changed: The date and time the Autonomous Data Guard role was switched for the Autonomous Database. For databases that have standbys in both the primary Data Guard region and a remote Data Guard standby region, this is the latest timestamp of either the database using the "primary" role in the primary Data Guard region, or database located in the remote Data Guard standby region.
         :param str time_disaster_recovery_role_changed: The date and time the Disaster Recovery role was switched for the standby Autonomous Database.
+        :param str time_maintenance_begin: The date and time when maintenance will begin.
+        :param str time_maintenance_end: The date and time when maintenance will end.
         """
         if availability_domain is not None:
             pulumi.set(__self__, "availability_domain", availability_domain)
@@ -3429,12 +3790,18 @@ class AutonomousDatabaseStandbyDb(dict):
             pulumi.set(__self__, "lag_time_in_seconds", lag_time_in_seconds)
         if lifecycle_details is not None:
             pulumi.set(__self__, "lifecycle_details", lifecycle_details)
+        if maintenance_target_component is not None:
+            pulumi.set(__self__, "maintenance_target_component", maintenance_target_component)
         if state is not None:
             pulumi.set(__self__, "state", state)
         if time_data_guard_role_changed is not None:
             pulumi.set(__self__, "time_data_guard_role_changed", time_data_guard_role_changed)
         if time_disaster_recovery_role_changed is not None:
             pulumi.set(__self__, "time_disaster_recovery_role_changed", time_disaster_recovery_role_changed)
+        if time_maintenance_begin is not None:
+            pulumi.set(__self__, "time_maintenance_begin", time_maintenance_begin)
+        if time_maintenance_end is not None:
+            pulumi.set(__self__, "time_maintenance_end", time_maintenance_end)
 
     @property
     @pulumi.getter(name="availabilityDomain")
@@ -3460,6 +3827,14 @@ class AutonomousDatabaseStandbyDb(dict):
         """
         return pulumi.get(self, "lifecycle_details")
 
+    @property
+    @pulumi.getter(name="maintenanceTargetComponent")
+    def maintenance_target_component(self) -> Optional[str]:
+        """
+        The component chosen for maintenance.
+        """
+        return pulumi.get(self, "maintenance_target_component")
+
     @property
     @pulumi.getter
     def state(self) -> Optional[str]:
@@ -3484,6 +3859,22 @@ class AutonomousDatabaseStandbyDb(dict):
         """
         return pulumi.get(self, "time_disaster_recovery_role_changed")
 
+    @property
+    @pulumi.getter(name="timeMaintenanceBegin")
+    def time_maintenance_begin(self) -> Optional[str]:
+        """
+        The date and time when maintenance will begin.
+        """
+        return pulumi.get(self, "time_maintenance_begin")
+
+    @property
+    @pulumi.getter(name="timeMaintenanceEnd")
+    def time_maintenance_end(self) -> Optional[str]:
+        """
+        The date and time when maintenance will end.
+        """
+        return pulumi.get(self, "time_maintenance_end")
+
 
 @pulumi.output_type
 class AutonomousExadataInfrastructureMaintenanceWindow(dict):
@@ -10465,92 +10856,95 @@ class ExadataInfrastructureComputeMaintenanceWindowMonth(dict):
 
 
 @pulumi.output_type
-class ExadataInfrastructureContact(dict):
+class ExadataInfrastructureConfigureExascaleManagementContact(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "isPrimary":
-            suggest = "is_primary"
-        elif key == "isContactMosValidated":
+        if key == "isContactMosValidated":
             suggest = "is_contact_mos_validated"
+        elif key == "isPrimary":
+            suggest = "is_primary"
         elif key == "phoneNumber":
             suggest = "phone_number"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in ExadataInfrastructureContact. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in ExadataInfrastructureConfigureExascaleManagementContact. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        ExadataInfrastructureContact.__key_warning(key)
+        ExadataInfrastructureConfigureExascaleManagementContact.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        ExadataInfrastructureContact.__key_warning(key)
+        ExadataInfrastructureConfigureExascaleManagementContact.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 email: str,
-                 is_primary: bool,
-                 name: str,
+                 email: Optional[str] = None,
                  is_contact_mos_validated: Optional[bool] = None,
+                 is_primary: Optional[bool] = None,
+                 name: Optional[str] = None,
                  phone_number: Optional[str] = None):
         """
-        :param str email: (Updatable) The email for the Exadata Infrastructure contact.
-        :param bool is_primary: (Updatable) If `true`, this Exadata Infrastructure contact is a primary contact. If `false`, this Exadata Infrastructure is a secondary contact.
-        :param str name: (Updatable) The name of the Exadata Infrastructure contact.
-        :param bool is_contact_mos_validated: (Updatable) If `true`, this Exadata Infrastructure contact is a valid My Oracle Support (MOS) contact. If `false`, this Exadata Infrastructure contact is not a valid MOS contact.
-        :param str phone_number: (Updatable) The phone number for the Exadata Infrastructure contact.
+        :param str email: The email for the Exadata Infrastructure contact.
+        :param bool is_contact_mos_validated: If `true`, this Exadata Infrastructure contact is a valid My Oracle Support (MOS) contact. If `false`, this Exadata Infrastructure contact is not a valid MOS contact.
+        :param bool is_primary: If `true`, this Exadata Infrastructure contact is a primary contact. If `false`, this Exadata Infrastructure is a secondary contact.
+        :param str name: Name of the month of the year.
+        :param str phone_number: The phone number for the Exadata Infrastructure contact.
         """
-        pulumi.set(__self__, "email", email)
-        pulumi.set(__self__, "is_primary", is_primary)
-        pulumi.set(__self__, "name", name)
+        if email is not None:
+            pulumi.set(__self__, "email", email)
         if is_contact_mos_validated is not None:
             pulumi.set(__self__, "is_contact_mos_validated", is_contact_mos_validated)
+        if is_primary is not None:
+            pulumi.set(__self__, "is_primary", is_primary)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
         if phone_number is not None:
             pulumi.set(__self__, "phone_number", phone_number)
 
     @property
     @pulumi.getter
-    def email(self) -> str:
+    def email(self) -> Optional[str]:
         """
-        (Updatable) The email for the Exadata Infrastructure contact.
+        The email for the Exadata Infrastructure contact.
         """
         return pulumi.get(self, "email")
 
     @property
-    @pulumi.getter(name="isPrimary")
-    def is_primary(self) -> bool:
+    @pulumi.getter(name="isContactMosValidated")
+    def is_contact_mos_validated(self) -> Optional[bool]:
         """
-        (Updatable) If `true`, this Exadata Infrastructure contact is a primary contact. If `false`, this Exadata Infrastructure is a secondary contact.
+        If `true`, this Exadata Infrastructure contact is a valid My Oracle Support (MOS) contact. If `false`, this Exadata Infrastructure contact is not a valid MOS contact.
         """
-        return pulumi.get(self, "is_primary")
+        return pulumi.get(self, "is_contact_mos_validated")
 
     @property
-    @pulumi.getter
-    def name(self) -> str:
+    @pulumi.getter(name="isPrimary")
+    def is_primary(self) -> Optional[bool]:
         """
-        (Updatable) The name of the Exadata Infrastructure contact.
+        If `true`, this Exadata Infrastructure contact is a primary contact. If `false`, this Exadata Infrastructure is a secondary contact.
         """
-        return pulumi.get(self, "name")
+        return pulumi.get(self, "is_primary")
 
     @property
-    @pulumi.getter(name="isContactMosValidated")
-    def is_contact_mos_validated(self) -> Optional[bool]:
+    @pulumi.getter
+    def name(self) -> Optional[str]:
         """
-        (Updatable) If `true`, this Exadata Infrastructure contact is a valid My Oracle Support (MOS) contact. If `false`, this Exadata Infrastructure contact is not a valid MOS contact.
+        Name of the month of the year.
         """
-        return pulumi.get(self, "is_contact_mos_validated")
+        return pulumi.get(self, "name")
 
     @property
     @pulumi.getter(name="phoneNumber")
     def phone_number(self) -> Optional[str]:
         """
-        (Updatable) The phone number for the Exadata Infrastructure contact.
+        The phone number for the Exadata Infrastructure contact.
         """
         return pulumi.get(self, "phone_number")
 
 
 @pulumi.output_type
-class ExadataInfrastructureDefinedFileSystemConfiguration(dict):
+class ExadataInfrastructureConfigureExascaleManagementDefinedFileSystemConfiguration(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
@@ -10564,14 +10958,14 @@ class ExadataInfrastructureDefinedFileSystemConfiguration(dict):
             suggest = "mount_point"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in ExadataInfrastructureDefinedFileSystemConfiguration. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in ExadataInfrastructureConfigureExascaleManagementDefinedFileSystemConfiguration. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        ExadataInfrastructureDefinedFileSystemConfiguration.__key_warning(key)
+        ExadataInfrastructureConfigureExascaleManagementDefinedFileSystemConfiguration.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        ExadataInfrastructureDefinedFileSystemConfiguration.__key_warning(key)
+        ExadataInfrastructureConfigureExascaleManagementDefinedFileSystemConfiguration.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
@@ -10627,6 +11021,551 @@ class ExadataInfrastructureDefinedFileSystemConfiguration(dict):
         return pulumi.get(self, "mount_point")
 
 
+@pulumi.output_type
+class ExadataInfrastructureConfigureExascaleManagementExascaleConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "availableStorageInGbs":
+            suggest = "available_storage_in_gbs"
+        elif key == "totalStorageInGbs":
+            suggest = "total_storage_in_gbs"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ExadataInfrastructureConfigureExascaleManagementExascaleConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ExadataInfrastructureConfigureExascaleManagementExascaleConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ExadataInfrastructureConfigureExascaleManagementExascaleConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 available_storage_in_gbs: Optional[int] = None,
+                 total_storage_in_gbs: Optional[int] = None):
+        """
+        :param int available_storage_in_gbs: Available storage size for Exascale in GBs.
+        :param int total_storage_in_gbs: Storage size needed for Exascale in GBs.
+               
+               
+               ** IMPORTANT **
+               Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
+        """
+        if available_storage_in_gbs is not None:
+            pulumi.set(__self__, "available_storage_in_gbs", available_storage_in_gbs)
+        if total_storage_in_gbs is not None:
+            pulumi.set(__self__, "total_storage_in_gbs", total_storage_in_gbs)
+
+    @property
+    @pulumi.getter(name="availableStorageInGbs")
+    def available_storage_in_gbs(self) -> Optional[int]:
+        """
+        Available storage size for Exascale in GBs.
+        """
+        return pulumi.get(self, "available_storage_in_gbs")
+
+    @property
+    @pulumi.getter(name="totalStorageInGbs")
+    def total_storage_in_gbs(self) -> Optional[int]:
+        """
+        Storage size needed for Exascale in GBs.
+
+
+        ** IMPORTANT **
+        Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
+        """
+        return pulumi.get(self, "total_storage_in_gbs")
+
+
+@pulumi.output_type
+class ExadataInfrastructureConfigureExascaleManagementMaintenanceWindow(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "customActionTimeoutInMins":
+            suggest = "custom_action_timeout_in_mins"
+        elif key == "daysOfWeeks":
+            suggest = "days_of_weeks"
+        elif key == "hoursOfDays":
+            suggest = "hours_of_days"
+        elif key == "isCustomActionTimeoutEnabled":
+            suggest = "is_custom_action_timeout_enabled"
+        elif key == "isMonthlyPatchingEnabled":
+            suggest = "is_monthly_patching_enabled"
+        elif key == "leadTimeInWeeks":
+            suggest = "lead_time_in_weeks"
+        elif key == "patchingMode":
+            suggest = "patching_mode"
+        elif key == "skipRus":
+            suggest = "skip_rus"
+        elif key == "weeksOfMonths":
+            suggest = "weeks_of_months"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ExadataInfrastructureConfigureExascaleManagementMaintenanceWindow. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ExadataInfrastructureConfigureExascaleManagementMaintenanceWindow.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ExadataInfrastructureConfigureExascaleManagementMaintenanceWindow.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 custom_action_timeout_in_mins: Optional[int] = None,
+                 days_of_weeks: Optional[Sequence['outputs.ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowDaysOfWeek']] = None,
+                 hours_of_days: Optional[Sequence[int]] = None,
+                 is_custom_action_timeout_enabled: Optional[bool] = None,
+                 is_monthly_patching_enabled: Optional[bool] = None,
+                 lead_time_in_weeks: Optional[int] = None,
+                 months: Optional[Sequence['outputs.ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowMonth']] = None,
+                 patching_mode: Optional[str] = None,
+                 preference: Optional[str] = None,
+                 skip_rus: Optional[Sequence[bool]] = None,
+                 weeks_of_months: Optional[Sequence[int]] = None):
+        """
+        :param int custom_action_timeout_in_mins: Determines the amount of time the system will wait before the start of each database server patching operation. Custom action timeout is in minutes and valid value is between 15 to 120 (inclusive).
+        :param Sequence['ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowDaysOfWeekArgs'] days_of_weeks: Days during the week when maintenance should be performed.
+        :param Sequence[int] hours_of_days: The window of hours during the day when maintenance should be performed. The window is a 4 hour slot. Valid values are - 0 - represents time slot 0:00 - 3:59 UTC - 4 - represents time slot 4:00 - 7:59 UTC - 8 - represents time slot 8:00 - 11:59 UTC - 12 - represents time slot 12:00 - 15:59 UTC - 16 - represents time slot 16:00 - 19:59 UTC - 20 - represents time slot 20:00 - 23:59 UTC
+        :param bool is_custom_action_timeout_enabled: If true, enables the configuration of a custom action timeout (waiting period) between database server patching operations.
+        :param bool is_monthly_patching_enabled: If true, enables the monthly patching option.
+        :param int lead_time_in_weeks: Lead time window allows user to set a lead time to prepare for a down time. The lead time is in weeks and valid value is between 1 to 4.
+        :param Sequence['ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowMonthArgs'] months: Months during the year when maintenance should be performed.
+        :param str patching_mode: Cloud Exadata infrastructure node patching method, either "ROLLING" or "NONROLLING". Default value is ROLLING.
+        :param str preference: The maintenance window scheduling preference.
+        :param Sequence[bool] skip_rus: If true, skips the release update (RU) for the quarter. You cannot skip two consecutive quarters. An RU skip request will only be honoured if the current version of the Autonomous Container Database is supported for current quarter.
+        :param Sequence[int] weeks_of_months: Weeks during the month when maintenance should be performed. Weeks start on the 1st, 8th, 15th, and 22nd days of the month, and have a duration of 7 days. Weeks start and end based on calendar dates, not days of the week. For example, to allow maintenance during the 2nd week of the month (from the 8th day to the 14th day of the month), use the value 2. Maintenance cannot be scheduled for the fifth week of months that contain more than 28 days. Note that this parameter works in conjunction with the  daysOfWeek and hoursOfDay parameters to allow you to specify specific days of the week and hours that maintenance will be performed.
+        """
+        if custom_action_timeout_in_mins is not None:
+            pulumi.set(__self__, "custom_action_timeout_in_mins", custom_action_timeout_in_mins)
+        if days_of_weeks is not None:
+            pulumi.set(__self__, "days_of_weeks", days_of_weeks)
+        if hours_of_days is not None:
+            pulumi.set(__self__, "hours_of_days", hours_of_days)
+        if is_custom_action_timeout_enabled is not None:
+            pulumi.set(__self__, "is_custom_action_timeout_enabled", is_custom_action_timeout_enabled)
+        if is_monthly_patching_enabled is not None:
+            pulumi.set(__self__, "is_monthly_patching_enabled", is_monthly_patching_enabled)
+        if lead_time_in_weeks is not None:
+            pulumi.set(__self__, "lead_time_in_weeks", lead_time_in_weeks)
+        if months is not None:
+            pulumi.set(__self__, "months", months)
+        if patching_mode is not None:
+            pulumi.set(__self__, "patching_mode", patching_mode)
+        if preference is not None:
+            pulumi.set(__self__, "preference", preference)
+        if skip_rus is not None:
+            pulumi.set(__self__, "skip_rus", skip_rus)
+        if weeks_of_months is not None:
+            pulumi.set(__self__, "weeks_of_months", weeks_of_months)
+
+    @property
+    @pulumi.getter(name="customActionTimeoutInMins")
+    def custom_action_timeout_in_mins(self) -> Optional[int]:
+        """
+        Determines the amount of time the system will wait before the start of each database server patching operation. Custom action timeout is in minutes and valid value is between 15 to 120 (inclusive).
+        """
+        return pulumi.get(self, "custom_action_timeout_in_mins")
+
+    @property
+    @pulumi.getter(name="daysOfWeeks")
+    def days_of_weeks(self) -> Optional[Sequence['outputs.ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowDaysOfWeek']]:
+        """
+        Days during the week when maintenance should be performed.
+        """
+        return pulumi.get(self, "days_of_weeks")
+
+    @property
+    @pulumi.getter(name="hoursOfDays")
+    def hours_of_days(self) -> Optional[Sequence[int]]:
+        """
+        The window of hours during the day when maintenance should be performed. The window is a 4 hour slot. Valid values are - 0 - represents time slot 0:00 - 3:59 UTC - 4 - represents time slot 4:00 - 7:59 UTC - 8 - represents time slot 8:00 - 11:59 UTC - 12 - represents time slot 12:00 - 15:59 UTC - 16 - represents time slot 16:00 - 19:59 UTC - 20 - represents time slot 20:00 - 23:59 UTC
+        """
+        return pulumi.get(self, "hours_of_days")
+
+    @property
+    @pulumi.getter(name="isCustomActionTimeoutEnabled")
+    def is_custom_action_timeout_enabled(self) -> Optional[bool]:
+        """
+        If true, enables the configuration of a custom action timeout (waiting period) between database server patching operations.
+        """
+        return pulumi.get(self, "is_custom_action_timeout_enabled")
+
+    @property
+    @pulumi.getter(name="isMonthlyPatchingEnabled")
+    def is_monthly_patching_enabled(self) -> Optional[bool]:
+        """
+        If true, enables the monthly patching option.
+        """
+        return pulumi.get(self, "is_monthly_patching_enabled")
+
+    @property
+    @pulumi.getter(name="leadTimeInWeeks")
+    def lead_time_in_weeks(self) -> Optional[int]:
+        """
+        Lead time window allows user to set a lead time to prepare for a down time. The lead time is in weeks and valid value is between 1 to 4.
+        """
+        return pulumi.get(self, "lead_time_in_weeks")
+
+    @property
+    @pulumi.getter
+    def months(self) -> Optional[Sequence['outputs.ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowMonth']]:
+        """
+        Months during the year when maintenance should be performed.
+        """
+        return pulumi.get(self, "months")
+
+    @property
+    @pulumi.getter(name="patchingMode")
+    def patching_mode(self) -> Optional[str]:
+        """
+        Cloud Exadata infrastructure node patching method, either "ROLLING" or "NONROLLING". Default value is ROLLING.
+        """
+        return pulumi.get(self, "patching_mode")
+
+    @property
+    @pulumi.getter
+    def preference(self) -> Optional[str]:
+        """
+        The maintenance window scheduling preference.
+        """
+        return pulumi.get(self, "preference")
+
+    @property
+    @pulumi.getter(name="skipRus")
+    def skip_rus(self) -> Optional[Sequence[bool]]:
+        """
+        If true, skips the release update (RU) for the quarter. You cannot skip two consecutive quarters. An RU skip request will only be honoured if the current version of the Autonomous Container Database is supported for current quarter.
+        """
+        return pulumi.get(self, "skip_rus")
+
+    @property
+    @pulumi.getter(name="weeksOfMonths")
+    def weeks_of_months(self) -> Optional[Sequence[int]]:
+        """
+        Weeks during the month when maintenance should be performed. Weeks start on the 1st, 8th, 15th, and 22nd days of the month, and have a duration of 7 days. Weeks start and end based on calendar dates, not days of the week. For example, to allow maintenance during the 2nd week of the month (from the 8th day to the 14th day of the month), use the value 2. Maintenance cannot be scheduled for the fifth week of months that contain more than 28 days. Note that this parameter works in conjunction with the  daysOfWeek and hoursOfDay parameters to allow you to specify specific days of the week and hours that maintenance will be performed.
+        """
+        return pulumi.get(self, "weeks_of_months")
+
+
+@pulumi.output_type
+class ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowDaysOfWeek(dict):
+    def __init__(__self__, *,
+                 name: Optional[str] = None):
+        """
+        :param str name: Name of the month of the year.
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        Name of the month of the year.
+        """
+        return pulumi.get(self, "name")
+
+
+@pulumi.output_type
+class ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowMonth(dict):
+    def __init__(__self__, *,
+                 name: Optional[str] = None):
+        """
+        :param str name: Name of the month of the year.
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        Name of the month of the year.
+        """
+        return pulumi.get(self, "name")
+
+
+@pulumi.output_type
+class ExadataInfrastructureConfigureExascaleManagementNetworkBondingModeDetail(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "backupNetworkBondingMode":
+            suggest = "backup_network_bonding_mode"
+        elif key == "clientNetworkBondingMode":
+            suggest = "client_network_bonding_mode"
+        elif key == "drNetworkBondingMode":
+            suggest = "dr_network_bonding_mode"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ExadataInfrastructureConfigureExascaleManagementNetworkBondingModeDetail. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ExadataInfrastructureConfigureExascaleManagementNetworkBondingModeDetail.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ExadataInfrastructureConfigureExascaleManagementNetworkBondingModeDetail.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 backup_network_bonding_mode: Optional[str] = None,
+                 client_network_bonding_mode: Optional[str] = None,
+                 dr_network_bonding_mode: Optional[str] = None):
+        """
+        :param str backup_network_bonding_mode: The network bonding mode for the Exadata infrastructure.
+        :param str client_network_bonding_mode: The network bonding mode for the Exadata infrastructure.
+        :param str dr_network_bonding_mode: The network bonding mode for the Exadata infrastructure.
+        """
+        if backup_network_bonding_mode is not None:
+            pulumi.set(__self__, "backup_network_bonding_mode", backup_network_bonding_mode)
+        if client_network_bonding_mode is not None:
+            pulumi.set(__self__, "client_network_bonding_mode", client_network_bonding_mode)
+        if dr_network_bonding_mode is not None:
+            pulumi.set(__self__, "dr_network_bonding_mode", dr_network_bonding_mode)
+
+    @property
+    @pulumi.getter(name="backupNetworkBondingMode")
+    def backup_network_bonding_mode(self) -> Optional[str]:
+        """
+        The network bonding mode for the Exadata infrastructure.
+        """
+        return pulumi.get(self, "backup_network_bonding_mode")
+
+    @property
+    @pulumi.getter(name="clientNetworkBondingMode")
+    def client_network_bonding_mode(self) -> Optional[str]:
+        """
+        The network bonding mode for the Exadata infrastructure.
+        """
+        return pulumi.get(self, "client_network_bonding_mode")
+
+    @property
+    @pulumi.getter(name="drNetworkBondingMode")
+    def dr_network_bonding_mode(self) -> Optional[str]:
+        """
+        The network bonding mode for the Exadata infrastructure.
+        """
+        return pulumi.get(self, "dr_network_bonding_mode")
+
+
+@pulumi.output_type
+class ExadataInfrastructureContact(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "isPrimary":
+            suggest = "is_primary"
+        elif key == "isContactMosValidated":
+            suggest = "is_contact_mos_validated"
+        elif key == "phoneNumber":
+            suggest = "phone_number"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ExadataInfrastructureContact. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ExadataInfrastructureContact.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ExadataInfrastructureContact.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 email: str,
+                 is_primary: bool,
+                 name: str,
+                 is_contact_mos_validated: Optional[bool] = None,
+                 phone_number: Optional[str] = None):
+        """
+        :param str email: (Updatable) The email for the Exadata Infrastructure contact.
+        :param bool is_primary: (Updatable) If `true`, this Exadata Infrastructure contact is a primary contact. If `false`, this Exadata Infrastructure is a secondary contact.
+        :param str name: (Updatable) The name of the Exadata Infrastructure contact.
+        :param bool is_contact_mos_validated: (Updatable) If `true`, this Exadata Infrastructure contact is a valid My Oracle Support (MOS) contact. If `false`, this Exadata Infrastructure contact is not a valid MOS contact.
+        :param str phone_number: (Updatable) The phone number for the Exadata Infrastructure contact.
+        """
+        pulumi.set(__self__, "email", email)
+        pulumi.set(__self__, "is_primary", is_primary)
+        pulumi.set(__self__, "name", name)
+        if is_contact_mos_validated is not None:
+            pulumi.set(__self__, "is_contact_mos_validated", is_contact_mos_validated)
+        if phone_number is not None:
+            pulumi.set(__self__, "phone_number", phone_number)
+
+    @property
+    @pulumi.getter
+    def email(self) -> str:
+        """
+        (Updatable) The email for the Exadata Infrastructure contact.
+        """
+        return pulumi.get(self, "email")
+
+    @property
+    @pulumi.getter(name="isPrimary")
+    def is_primary(self) -> bool:
+        """
+        (Updatable) If `true`, this Exadata Infrastructure contact is a primary contact. If `false`, this Exadata Infrastructure is a secondary contact.
+        """
+        return pulumi.get(self, "is_primary")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        (Updatable) The name of the Exadata Infrastructure contact.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="isContactMosValidated")
+    def is_contact_mos_validated(self) -> Optional[bool]:
+        """
+        (Updatable) If `true`, this Exadata Infrastructure contact is a valid My Oracle Support (MOS) contact. If `false`, this Exadata Infrastructure contact is not a valid MOS contact.
+        """
+        return pulumi.get(self, "is_contact_mos_validated")
+
+    @property
+    @pulumi.getter(name="phoneNumber")
+    def phone_number(self) -> Optional[str]:
+        """
+        (Updatable) The phone number for the Exadata Infrastructure contact.
+        """
+        return pulumi.get(self, "phone_number")
+
+
+@pulumi.output_type
+class ExadataInfrastructureDefinedFileSystemConfiguration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "isBackupPartition":
+            suggest = "is_backup_partition"
+        elif key == "isResizable":
+            suggest = "is_resizable"
+        elif key == "minSizeGb":
+            suggest = "min_size_gb"
+        elif key == "mountPoint":
+            suggest = "mount_point"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ExadataInfrastructureDefinedFileSystemConfiguration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ExadataInfrastructureDefinedFileSystemConfiguration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ExadataInfrastructureDefinedFileSystemConfiguration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 is_backup_partition: Optional[bool] = None,
+                 is_resizable: Optional[bool] = None,
+                 min_size_gb: Optional[int] = None,
+                 mount_point: Optional[str] = None):
+        """
+        :param bool is_backup_partition: If true, the file system is used to create a backup prior to Exadata VM OS update.
+        :param bool is_resizable: If true, the file system resize is allowed for the Exadata Infrastructure cluster. If false, the file system resize is not allowed.
+        :param int min_size_gb: The minimum size of file system.
+        :param str mount_point: The mount point of file system.
+        """
+        if is_backup_partition is not None:
+            pulumi.set(__self__, "is_backup_partition", is_backup_partition)
+        if is_resizable is not None:
+            pulumi.set(__self__, "is_resizable", is_resizable)
+        if min_size_gb is not None:
+            pulumi.set(__self__, "min_size_gb", min_size_gb)
+        if mount_point is not None:
+            pulumi.set(__self__, "mount_point", mount_point)
+
+    @property
+    @pulumi.getter(name="isBackupPartition")
+    def is_backup_partition(self) -> Optional[bool]:
+        """
+        If true, the file system is used to create a backup prior to Exadata VM OS update.
+        """
+        return pulumi.get(self, "is_backup_partition")
+
+    @property
+    @pulumi.getter(name="isResizable")
+    def is_resizable(self) -> Optional[bool]:
+        """
+        If true, the file system resize is allowed for the Exadata Infrastructure cluster. If false, the file system resize is not allowed.
+        """
+        return pulumi.get(self, "is_resizable")
+
+    @property
+    @pulumi.getter(name="minSizeGb")
+    def min_size_gb(self) -> Optional[int]:
+        """
+        The minimum size of file system.
+        """
+        return pulumi.get(self, "min_size_gb")
+
+    @property
+    @pulumi.getter(name="mountPoint")
+    def mount_point(self) -> Optional[str]:
+        """
+        The mount point of file system.
+        """
+        return pulumi.get(self, "mount_point")
+
+
+@pulumi.output_type
+class ExadataInfrastructureExascaleConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "availableStorageInGbs":
+            suggest = "available_storage_in_gbs"
+        elif key == "totalStorageInGbs":
+            suggest = "total_storage_in_gbs"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ExadataInfrastructureExascaleConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ExadataInfrastructureExascaleConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ExadataInfrastructureExascaleConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 available_storage_in_gbs: Optional[int] = None,
+                 total_storage_in_gbs: Optional[int] = None):
+        """
+        :param int available_storage_in_gbs: Available storage size for Exascale in GBs.
+        :param int total_storage_in_gbs: Storage size needed for Exascale in GBs.
+        """
+        if available_storage_in_gbs is not None:
+            pulumi.set(__self__, "available_storage_in_gbs", available_storage_in_gbs)
+        if total_storage_in_gbs is not None:
+            pulumi.set(__self__, "total_storage_in_gbs", total_storage_in_gbs)
+
+    @property
+    @pulumi.getter(name="availableStorageInGbs")
+    def available_storage_in_gbs(self) -> Optional[int]:
+        """
+        Available storage size for Exascale in GBs.
+        """
+        return pulumi.get(self, "available_storage_in_gbs")
+
+    @property
+    @pulumi.getter(name="totalStorageInGbs")
+    def total_storage_in_gbs(self) -> Optional[int]:
+        """
+        Storage size needed for Exascale in GBs.
+        """
+        return pulumi.get(self, "total_storage_in_gbs")
+
+
 @pulumi.output_type
 class ExadataInfrastructureMaintenanceWindow(dict):
     @staticmethod
@@ -14886,6 +15825,7 @@ class GetApplicationVipsApplicationVipResult(dict):
                  hostname_label: str,
                  id: str,
                  ip_address: str,
+                 ipv6address: str,
                  lifecycle_details: str,
                  state: str,
                  subnet_id: str,
@@ -14897,7 +15837,8 @@ class GetApplicationVipsApplicationVipResult(dict):
         :param Mapping[str, str] freeform_tags: Free-form tags for this resource. Each tag is a simple key-value pair with no predefined name, type, or namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).  Example: `{"Department": "Finance"}`
         :param str hostname_label: The hostname of the application virtual IP (VIP) address.
         :param str id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the application virtual IP (VIP) address.
-        :param str ip_address: The application virtual IP (VIP) address.
+        :param str ip_address: The application virtual IP (VIP) IPv4 address.
+        :param str ipv6address: The application virtual IP (VIP) IPv6 address.
         :param str lifecycle_details: Additional information about the current lifecycle state of the application virtual IP (VIP) address.
         :param str state: A filter to return only resources that match the given lifecycle state exactly.
         :param str subnet_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the subnet associated with the application virtual IP (VIP) address.
@@ -14911,6 +15852,7 @@ class GetApplicationVipsApplicationVipResult(dict):
         pulumi.set(__self__, "hostname_label", hostname_label)
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "ip_address", ip_address)
+        pulumi.set(__self__, "ipv6address", ipv6address)
         pulumi.set(__self__, "lifecycle_details", lifecycle_details)
         pulumi.set(__self__, "state", state)
         pulumi.set(__self__, "subnet_id", subnet_id)
@@ -14973,10 +15915,18 @@ class GetApplicationVipsApplicationVipResult(dict):
     @pulumi.getter(name="ipAddress")
     def ip_address(self) -> str:
         """
-        The application virtual IP (VIP) address.
+        The application virtual IP (VIP) IPv4 address.
         """
         return pulumi.get(self, "ip_address")
 
+    @property
+    @pulumi.getter
+    def ipv6address(self) -> str:
+        """
+        The application virtual IP (VIP) IPv6 address.
+        """
+        return pulumi.get(self, "ipv6address")
+
     @property
     @pulumi.getter(name="lifecycleDetails")
     def lifecycle_details(self) -> str:
@@ -15088,6 +16038,123 @@ class GetAutonomousCharacterSetsFilterResult(dict):
         return pulumi.get(self, "regex")
 
 
+@pulumi.output_type
+class GetAutonomousContainerDatabaseAssociatedBackupConfigurationDetailResult(dict):
+    def __init__(__self__, *,
+                 backup_destination_attach_histories: Sequence[str],
+                 dbrs_policy_id: str,
+                 id: str,
+                 internet_proxy: str,
+                 recovery_window_in_days: int,
+                 space_utilized_in_gbs: int,
+                 time_at_which_storage_details_are_updated: str,
+                 type: str,
+                 vpc_password: str,
+                 vpc_user: str):
+        """
+        :param Sequence[str] backup_destination_attach_histories: The timestamps at which this backup destination is used as the preferred destination to host the Autonomous Container Database backups.
+        :param str dbrs_policy_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the DBRS policy used for backup.
+        :param str id: The id of the Autonomous Database [Vault](https://docs.cloud.oracle.com/iaas/Content/KeyManagement/Concepts/keyoverview.htm#concepts) service key management history entry.
+        :param str internet_proxy: Proxy URL to connect to object store.
+        :param int recovery_window_in_days: Number of days between the current and earliest point of recoverability covered by automatic backups.
+        :param int space_utilized_in_gbs: The total space utilized (in GBs) by this Autonomous Container Database on this backup destination, rounded to the nearest integer.
+        :param str time_at_which_storage_details_are_updated: The latest timestamp when the backup destination details, such as 'spaceUtilized,' are updated.
+        :param str type: Type of the database backup destination.
+        :param str vpc_password: For a RECOVERY_APPLIANCE backup destination, the password for the VPC user that is used to access the Recovery Appliance.
+        :param str vpc_user: For a RECOVERY_APPLIANCE backup destination, the Virtual Private Catalog (VPC) user that is used to access the Recovery Appliance.
+        """
+        pulumi.set(__self__, "backup_destination_attach_histories", backup_destination_attach_histories)
+        pulumi.set(__self__, "dbrs_policy_id", dbrs_policy_id)
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "internet_proxy", internet_proxy)
+        pulumi.set(__self__, "recovery_window_in_days", recovery_window_in_days)
+        pulumi.set(__self__, "space_utilized_in_gbs", space_utilized_in_gbs)
+        pulumi.set(__self__, "time_at_which_storage_details_are_updated", time_at_which_storage_details_are_updated)
+        pulumi.set(__self__, "type", type)
+        pulumi.set(__self__, "vpc_password", vpc_password)
+        pulumi.set(__self__, "vpc_user", vpc_user)
+
+    @property
+    @pulumi.getter(name="backupDestinationAttachHistories")
+    def backup_destination_attach_histories(self) -> Sequence[str]:
+        """
+        The timestamps at which this backup destination is used as the preferred destination to host the Autonomous Container Database backups.
+        """
+        return pulumi.get(self, "backup_destination_attach_histories")
+
+    @property
+    @pulumi.getter(name="dbrsPolicyId")
+    def dbrs_policy_id(self) -> str:
+        """
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the DBRS policy used for backup.
+        """
+        return pulumi.get(self, "dbrs_policy_id")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        The id of the Autonomous Database [Vault](https://docs.cloud.oracle.com/iaas/Content/KeyManagement/Concepts/keyoverview.htm#concepts) service key management history entry.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="internetProxy")
+    def internet_proxy(self) -> str:
+        """
+        Proxy URL to connect to object store.
+        """
+        return pulumi.get(self, "internet_proxy")
+
+    @property
+    @pulumi.getter(name="recoveryWindowInDays")
+    def recovery_window_in_days(self) -> int:
+        """
+        Number of days between the current and earliest point of recoverability covered by automatic backups.
+        """
+        return pulumi.get(self, "recovery_window_in_days")
+
+    @property
+    @pulumi.getter(name="spaceUtilizedInGbs")
+    def space_utilized_in_gbs(self) -> int:
+        """
+        The total space utilized (in GBs) by this Autonomous Container Database on this backup destination, rounded to the nearest integer.
+        """
+        return pulumi.get(self, "space_utilized_in_gbs")
+
+    @property
+    @pulumi.getter(name="timeAtWhichStorageDetailsAreUpdated")
+    def time_at_which_storage_details_are_updated(self) -> str:
+        """
+        The latest timestamp when the backup destination details, such as 'spaceUtilized,' are updated.
+        """
+        return pulumi.get(self, "time_at_which_storage_details_are_updated")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        Type of the database backup destination.
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter(name="vpcPassword")
+    def vpc_password(self) -> str:
+        """
+        For a RECOVERY_APPLIANCE backup destination, the password for the VPC user that is used to access the Recovery Appliance.
+        """
+        return pulumi.get(self, "vpc_password")
+
+    @property
+    @pulumi.getter(name="vpcUser")
+    def vpc_user(self) -> str:
+        """
+        For a RECOVERY_APPLIANCE backup destination, the Virtual Private Catalog (VPC) user that is used to access the Recovery Appliance.
+        """
+        return pulumi.get(self, "vpc_user")
+
+
 @pulumi.output_type
 class GetAutonomousContainerDatabaseBackupConfigResult(dict):
     def __init__(__self__, *,
@@ -15095,7 +16162,7 @@ class GetAutonomousContainerDatabaseBackupConfigResult(dict):
                  recovery_window_in_days: int):
         """
         :param Sequence['GetAutonomousContainerDatabaseBackupConfigBackupDestinationDetailArgs'] backup_destination_details: Backup destination details.
-        :param int recovery_window_in_days: Number of days between the current and the earliest point of recoverability covered by automatic backups. This value applies to automatic backups. After a new automatic backup has been created, Oracle removes old automatic backups that are created before the window. When the value is updated, it is applied to all existing automatic backups. If the number of specified days is 0 then there will be no backups.
+        :param int recovery_window_in_days: Number of days between the current and earliest point of recoverability covered by automatic backups.
         """
         pulumi.set(__self__, "backup_destination_details", backup_destination_details)
         pulumi.set(__self__, "recovery_window_in_days", recovery_window_in_days)
@@ -15112,7 +16179,7 @@ class GetAutonomousContainerDatabaseBackupConfigResult(dict):
     @pulumi.getter(name="recoveryWindowInDays")
     def recovery_window_in_days(self) -> int:
         """
-        Number of days between the current and the earliest point of recoverability covered by automatic backups. This value applies to automatic backups. After a new automatic backup has been created, Oracle removes old automatic backups that are created before the window. When the value is updated, it is applied to all existing automatic backups. If the number of specified days is 0 then there will be no backups.
+        Number of days between the current and earliest point of recoverability covered by automatic backups.
         """
         return pulumi.get(self, "recovery_window_in_days")
 
@@ -15179,6 +16246,46 @@ class GetAutonomousContainerDatabaseBackupConfigBackupDestinationDetailResult(di
         return pulumi.get(self, "vpc_user")
 
 
+@pulumi.output_type
+class GetAutonomousContainerDatabaseBackupDestinationPropertiesListResult(dict):
+    def __init__(__self__, *,
+                 backup_destination_attach_histories: Sequence[str],
+                 space_utilized_in_gbs: int,
+                 time_at_which_storage_details_are_updated: str):
+        """
+        :param Sequence[str] backup_destination_attach_histories: The timestamps at which this backup destination is used as the preferred destination to host the Autonomous Container Database backups.
+        :param int space_utilized_in_gbs: The total space utilized (in GBs) by this Autonomous Container Database on this backup destination, rounded to the nearest integer.
+        :param str time_at_which_storage_details_are_updated: The latest timestamp when the backup destination details, such as 'spaceUtilized,' are updated.
+        """
+        pulumi.set(__self__, "backup_destination_attach_histories", backup_destination_attach_histories)
+        pulumi.set(__self__, "space_utilized_in_gbs", space_utilized_in_gbs)
+        pulumi.set(__self__, "time_at_which_storage_details_are_updated", time_at_which_storage_details_are_updated)
+
+    @property
+    @pulumi.getter(name="backupDestinationAttachHistories")
+    def backup_destination_attach_histories(self) -> Sequence[str]:
+        """
+        The timestamps at which this backup destination is used as the preferred destination to host the Autonomous Container Database backups.
+        """
+        return pulumi.get(self, "backup_destination_attach_histories")
+
+    @property
+    @pulumi.getter(name="spaceUtilizedInGbs")
+    def space_utilized_in_gbs(self) -> int:
+        """
+        The total space utilized (in GBs) by this Autonomous Container Database on this backup destination, rounded to the nearest integer.
+        """
+        return pulumi.get(self, "space_utilized_in_gbs")
+
+    @property
+    @pulumi.getter(name="timeAtWhichStorageDetailsAreUpdated")
+    def time_at_which_storage_details_are_updated(self) -> str:
+        """
+        The latest timestamp when the backup destination details, such as 'spaceUtilized,' are updated.
+        """
+        return pulumi.get(self, "time_at_which_storage_details_are_updated")
+
+
 @pulumi.output_type
 class GetAutonomousContainerDatabaseDataguardAssociationPeerAutonomousContainerDatabaseBackupConfigResult(dict):
     def __init__(__self__, *,
@@ -16001,7 +17108,7 @@ class GetAutonomousContainerDatabasePeerAutonomousContainerDatabaseBackupConfigR
                  recovery_window_in_days: int):
         """
         :param Sequence['GetAutonomousContainerDatabasePeerAutonomousContainerDatabaseBackupConfigBackupDestinationDetailArgs'] backup_destination_details: Backup destination details.
-        :param int recovery_window_in_days: Number of days between the current and the earliest point of recoverability covered by automatic backups. This value applies to automatic backups. After a new automatic backup has been created, Oracle removes old automatic backups that are created before the window. When the value is updated, it is applied to all existing automatic backups. If the number of specified days is 0 then there will be no backups.
+        :param int recovery_window_in_days: Number of days between the current and earliest point of recoverability covered by automatic backups.
         """
         pulumi.set(__self__, "backup_destination_details", backup_destination_details)
         pulumi.set(__self__, "recovery_window_in_days", recovery_window_in_days)
@@ -16018,7 +17125,7 @@ class GetAutonomousContainerDatabasePeerAutonomousContainerDatabaseBackupConfigR
     @pulumi.getter(name="recoveryWindowInDays")
     def recovery_window_in_days(self) -> int:
         """
-        Number of days between the current and the earliest point of recoverability covered by automatic backups. This value applies to automatic backups. After a new automatic backup has been created, Oracle removes old automatic backups that are created before the window. When the value is updated, it is applied to all existing automatic backups. If the number of specified days is 0 then there will be no backups.
+        Number of days between the current and earliest point of recoverability covered by automatic backups.
         """
         return pulumi.get(self, "recovery_window_in_days")
 
@@ -16085,6 +17192,46 @@ class GetAutonomousContainerDatabasePeerAutonomousContainerDatabaseBackupConfigB
         return pulumi.get(self, "vpc_user")
 
 
+@pulumi.output_type
+class GetAutonomousContainerDatabaseRecoveryApplianceDetailResult(dict):
+    def __init__(__self__, *,
+                 allocated_storage_size_in_gbs: int,
+                 recovery_window_in_days: int,
+                 time_recovery_appliance_details_updated: str):
+        """
+        :param int allocated_storage_size_in_gbs: The storage size of the backup destination allocated for an Autonomous Container Database to store backups on the recovery appliance, in GBs, rounded to the nearest integer.
+        :param int recovery_window_in_days: Number of days between the current and earliest point of recoverability covered by automatic backups.
+        :param str time_recovery_appliance_details_updated: The time when the recovery appliance details are updated.
+        """
+        pulumi.set(__self__, "allocated_storage_size_in_gbs", allocated_storage_size_in_gbs)
+        pulumi.set(__self__, "recovery_window_in_days", recovery_window_in_days)
+        pulumi.set(__self__, "time_recovery_appliance_details_updated", time_recovery_appliance_details_updated)
+
+    @property
+    @pulumi.getter(name="allocatedStorageSizeInGbs")
+    def allocated_storage_size_in_gbs(self) -> int:
+        """
+        The storage size of the backup destination allocated for an Autonomous Container Database to store backups on the recovery appliance, in GBs, rounded to the nearest integer.
+        """
+        return pulumi.get(self, "allocated_storage_size_in_gbs")
+
+    @property
+    @pulumi.getter(name="recoveryWindowInDays")
+    def recovery_window_in_days(self) -> int:
+        """
+        Number of days between the current and earliest point of recoverability covered by automatic backups.
+        """
+        return pulumi.get(self, "recovery_window_in_days")
+
+    @property
+    @pulumi.getter(name="timeRecoveryApplianceDetailsUpdated")
+    def time_recovery_appliance_details_updated(self) -> str:
+        """
+        The time when the recovery appliance details are updated.
+        """
+        return pulumi.get(self, "time_recovery_appliance_details_updated")
+
+
 @pulumi.output_type
 class GetAutonomousContainerDatabaseResourceUsageAutonomousContainerDatabaseVmUsageResult(dict):
     def __init__(__self__, *,
@@ -16279,11 +17426,13 @@ class GetAutonomousContainerDatabaseVersionsFilterResult(dict):
 @pulumi.output_type
 class GetAutonomousContainerDatabasesAutonomousContainerDatabaseResult(dict):
     def __init__(__self__, *,
+                 associated_backup_configuration_details: Sequence['outputs.GetAutonomousContainerDatabasesAutonomousContainerDatabaseAssociatedBackupConfigurationDetailResult'],
                  autonomous_exadata_infrastructure_id: str,
                  autonomous_vm_cluster_id: str,
                  availability_domain: str,
                  available_cpus: float,
                  backup_configs: Sequence['outputs.GetAutonomousContainerDatabasesAutonomousContainerDatabaseBackupConfigResult'],
+                 backup_destination_properties_lists: Sequence['outputs.GetAutonomousContainerDatabasesAutonomousContainerDatabaseBackupDestinationPropertiesListResult'],
                  cloud_autonomous_vm_cluster_id: str,
                  compartment_id: str,
                  compute_model: str,
@@ -16329,6 +17478,7 @@ class GetAutonomousContainerDatabasesAutonomousContainerDatabaseResult(dict):
                  provisionable_cpuses: Sequence[float],
                  provisioned_cpus: float,
                  reclaimable_cpus: float,
+                 recovery_appliance_details: Sequence['outputs.GetAutonomousContainerDatabasesAutonomousContainerDatabaseRecoveryApplianceDetailResult'],
                  reserved_cpus: float,
                  role: str,
                  rotate_key_trigger: bool,
@@ -16343,11 +17493,13 @@ class GetAutonomousContainerDatabasesAutonomousContainerDatabaseResult(dict):
                  version_preference: str,
                  vm_failover_reservation: int):
         """
+        :param Sequence['GetAutonomousContainerDatabasesAutonomousContainerDatabaseAssociatedBackupConfigurationDetailArgs'] associated_backup_configuration_details: A backup config object holds information about preferred backup destinations only. This object holds information about the associated backup destinations, such as secondary backup destinations created for local backups or remote replicated backups.
         :param str autonomous_exadata_infrastructure_id: The Autonomous Exadata Infrastructure [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
         :param str autonomous_vm_cluster_id: The Autonomous VM Cluster [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
         :param str availability_domain: A filter to return only resources that match the given availability domain exactly.
         :param float available_cpus: Sum of CPUs available on the Autonomous VM Cluster + Sum of reclaimable CPUs available in the Autonomous Container Database.<br> For Autonomous Databases on Dedicated Exadata Infrastructure, the CPU type (OCPUs or ECPUs) is determined by the parent Autonomous Exadata VM Cluster's compute model. See [Compute Models in Autonomous Database on Dedicated Exadata Infrastructure](https://docs.oracle.com/en/cloud/paas/autonomous-database/dedicated/adbak) for more details.
         :param Sequence['GetAutonomousContainerDatabasesAutonomousContainerDatabaseBackupConfigArgs'] backup_configs: Backup options for the Autonomous Container Database.
+        :param Sequence['GetAutonomousContainerDatabasesAutonomousContainerDatabaseBackupDestinationPropertiesListArgs'] backup_destination_properties_lists: This list describes the backup destination properties associated with the Autonomous Container Database (ACD) 's preferred backup destination. The object at a given index is associated with the destination present at the same index in the backup destination details list of the ACD Backup Configuration.
         :param str cloud_autonomous_vm_cluster_id: The cloud Autonomous VM Cluster [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
         :param str compartment_id: The compartment [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
         :param str compute_model: The compute model of the Autonomous Container Database. For Autonomous Database on Dedicated Exadata Infrastructure, the CPU type (ECPUs or OCPUs) is determined by the parent Autonomous Exadata VM Cluster's compute model. ECPU compute model is the recommended model and OCPU compute model is legacy. See [Compute Models in Autonomous Database on Dedicated Exadata Infrastructure](https://docs.oracle.com/en/cloud/paas/autonomous-database/dedicated/adbak) for more details.
@@ -16379,6 +17531,7 @@ class GetAutonomousContainerDatabasesAutonomousContainerDatabaseResult(dict):
         :param Sequence[float] provisionable_cpuses: An array of CPU values that can be used to successfully provision a single Autonomous Database.
         :param float provisioned_cpus: The number of CPUs provisioned in an Autonomous Container Database.
         :param float reclaimable_cpus: CPUs that continue to be included in the count of CPUs available to the Autonomous Container Database even after one of its Autonomous Database is terminated or scaled down. You can release them to the available CPUs at its parent Autonomous VM Cluster level by restarting the Autonomous Container Database.
+        :param Sequence['GetAutonomousContainerDatabasesAutonomousContainerDatabaseRecoveryApplianceDetailArgs'] recovery_appliance_details: Information about the recovery appliance configuration associated with the Autonomous Container Database.
         :param float reserved_cpus: The number of CPUs reserved in an Autonomous Container Database.
         :param str role: The Data Guard role of the Autonomous Container Database or Autonomous Database, if Autonomous Data Guard is enabled.
         :param str service_level_agreement_type: A filter to return only resources that match the given service level agreement type exactly.
@@ -16392,11 +17545,13 @@ class GetAutonomousContainerDatabasesAutonomousContainerDatabaseResult(dict):
         :param str version_preference: The next maintenance version preference.
         :param int vm_failover_reservation: The percentage of CPUs reserved across nodes to support node failover. Allowed values are 0%, 25%, and 50%, with 50% being the default option.
         """
+        pulumi.set(__self__, "associated_backup_configuration_details", associated_backup_configuration_details)
         pulumi.set(__self__, "autonomous_exadata_infrastructure_id", autonomous_exadata_infrastructure_id)
         pulumi.set(__self__, "autonomous_vm_cluster_id", autonomous_vm_cluster_id)
         pulumi.set(__self__, "availability_domain", availability_domain)
         pulumi.set(__self__, "available_cpus", available_cpus)
         pulumi.set(__self__, "backup_configs", backup_configs)
+        pulumi.set(__self__, "backup_destination_properties_lists", backup_destination_properties_lists)
         pulumi.set(__self__, "cloud_autonomous_vm_cluster_id", cloud_autonomous_vm_cluster_id)
         pulumi.set(__self__, "compartment_id", compartment_id)
         pulumi.set(__self__, "compute_model", compute_model)
@@ -16442,6 +17597,7 @@ class GetAutonomousContainerDatabasesAutonomousContainerDatabaseResult(dict):
         pulumi.set(__self__, "provisionable_cpuses", provisionable_cpuses)
         pulumi.set(__self__, "provisioned_cpus", provisioned_cpus)
         pulumi.set(__self__, "reclaimable_cpus", reclaimable_cpus)
+        pulumi.set(__self__, "recovery_appliance_details", recovery_appliance_details)
         pulumi.set(__self__, "reserved_cpus", reserved_cpus)
         pulumi.set(__self__, "role", role)
         pulumi.set(__self__, "rotate_key_trigger", rotate_key_trigger)
@@ -16456,6 +17612,14 @@ class GetAutonomousContainerDatabasesAutonomousContainerDatabaseResult(dict):
         pulumi.set(__self__, "version_preference", version_preference)
         pulumi.set(__self__, "vm_failover_reservation", vm_failover_reservation)
 
+    @property
+    @pulumi.getter(name="associatedBackupConfigurationDetails")
+    def associated_backup_configuration_details(self) -> Sequence['outputs.GetAutonomousContainerDatabasesAutonomousContainerDatabaseAssociatedBackupConfigurationDetailResult']:
+        """
+        A backup config object holds information about preferred backup destinations only. This object holds information about the associated backup destinations, such as secondary backup destinations created for local backups or remote replicated backups.
+        """
+        return pulumi.get(self, "associated_backup_configuration_details")
+
     @property
     @pulumi.getter(name="autonomousExadataInfrastructureId")
     def autonomous_exadata_infrastructure_id(self) -> str:
@@ -16496,6 +17660,14 @@ class GetAutonomousContainerDatabasesAutonomousContainerDatabaseResult(dict):
         """
         return pulumi.get(self, "backup_configs")
 
+    @property
+    @pulumi.getter(name="backupDestinationPropertiesLists")
+    def backup_destination_properties_lists(self) -> Sequence['outputs.GetAutonomousContainerDatabasesAutonomousContainerDatabaseBackupDestinationPropertiesListResult']:
+        """
+        This list describes the backup destination properties associated with the Autonomous Container Database (ACD) 's preferred backup destination. The object at a given index is associated with the destination present at the same index in the backup destination details list of the ACD Backup Configuration.
+        """
+        return pulumi.get(self, "backup_destination_properties_lists")
+
     @property
     @pulumi.getter(name="cloudAutonomousVmClusterId")
     def cloud_autonomous_vm_cluster_id(self) -> str:
@@ -16814,6 +17986,14 @@ class GetAutonomousContainerDatabasesAutonomousContainerDatabaseResult(dict):
         """
         return pulumi.get(self, "reclaimable_cpus")
 
+    @property
+    @pulumi.getter(name="recoveryApplianceDetails")
+    def recovery_appliance_details(self) -> Sequence['outputs.GetAutonomousContainerDatabasesAutonomousContainerDatabaseRecoveryApplianceDetailResult']:
+        """
+        Information about the recovery appliance configuration associated with the Autonomous Container Database.
+        """
+        return pulumi.get(self, "recovery_appliance_details")
+
     @property
     @pulumi.getter(name="reservedCpus")
     def reserved_cpus(self) -> float:
@@ -16916,6 +18096,123 @@ class GetAutonomousContainerDatabasesAutonomousContainerDatabaseResult(dict):
         return pulumi.get(self, "vm_failover_reservation")
 
 
+@pulumi.output_type
+class GetAutonomousContainerDatabasesAutonomousContainerDatabaseAssociatedBackupConfigurationDetailResult(dict):
+    def __init__(__self__, *,
+                 backup_destination_attach_histories: Sequence[str],
+                 dbrs_policy_id: str,
+                 id: str,
+                 internet_proxy: str,
+                 recovery_window_in_days: int,
+                 space_utilized_in_gbs: int,
+                 time_at_which_storage_details_are_updated: str,
+                 type: str,
+                 vpc_password: str,
+                 vpc_user: str):
+        """
+        :param Sequence[str] backup_destination_attach_histories: The timestamps at which this backup destination is used as the preferred destination to host the Autonomous Container Database backups.
+        :param str dbrs_policy_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the DBRS policy used for backup.
+        :param str id: The id of the Autonomous Database [Vault](https://docs.cloud.oracle.com/iaas/Content/KeyManagement/Concepts/keyoverview.htm#concepts) service key management history entry.
+        :param str internet_proxy: Proxy URL to connect to object store.
+        :param int recovery_window_in_days: Number of days between the current and earliest point of recoverability covered by automatic backups.
+        :param int space_utilized_in_gbs: The total space utilized (in GBs) by this Autonomous Container Database on this backup destination, rounded to the nearest integer.
+        :param str time_at_which_storage_details_are_updated: The latest timestamp when the backup destination details, such as 'spaceUtilized,' are updated.
+        :param str type: Type of the database backup destination.
+        :param str vpc_password: For a RECOVERY_APPLIANCE backup destination, the password for the VPC user that is used to access the Recovery Appliance.
+        :param str vpc_user: For a RECOVERY_APPLIANCE backup destination, the Virtual Private Catalog (VPC) user that is used to access the Recovery Appliance.
+        """
+        pulumi.set(__self__, "backup_destination_attach_histories", backup_destination_attach_histories)
+        pulumi.set(__self__, "dbrs_policy_id", dbrs_policy_id)
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "internet_proxy", internet_proxy)
+        pulumi.set(__self__, "recovery_window_in_days", recovery_window_in_days)
+        pulumi.set(__self__, "space_utilized_in_gbs", space_utilized_in_gbs)
+        pulumi.set(__self__, "time_at_which_storage_details_are_updated", time_at_which_storage_details_are_updated)
+        pulumi.set(__self__, "type", type)
+        pulumi.set(__self__, "vpc_password", vpc_password)
+        pulumi.set(__self__, "vpc_user", vpc_user)
+
+    @property
+    @pulumi.getter(name="backupDestinationAttachHistories")
+    def backup_destination_attach_histories(self) -> Sequence[str]:
+        """
+        The timestamps at which this backup destination is used as the preferred destination to host the Autonomous Container Database backups.
+        """
+        return pulumi.get(self, "backup_destination_attach_histories")
+
+    @property
+    @pulumi.getter(name="dbrsPolicyId")
+    def dbrs_policy_id(self) -> str:
+        """
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the DBRS policy used for backup.
+        """
+        return pulumi.get(self, "dbrs_policy_id")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        The id of the Autonomous Database [Vault](https://docs.cloud.oracle.com/iaas/Content/KeyManagement/Concepts/keyoverview.htm#concepts) service key management history entry.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="internetProxy")
+    def internet_proxy(self) -> str:
+        """
+        Proxy URL to connect to object store.
+        """
+        return pulumi.get(self, "internet_proxy")
+
+    @property
+    @pulumi.getter(name="recoveryWindowInDays")
+    def recovery_window_in_days(self) -> int:
+        """
+        Number of days between the current and earliest point of recoverability covered by automatic backups.
+        """
+        return pulumi.get(self, "recovery_window_in_days")
+
+    @property
+    @pulumi.getter(name="spaceUtilizedInGbs")
+    def space_utilized_in_gbs(self) -> int:
+        """
+        The total space utilized (in GBs) by this Autonomous Container Database on this backup destination, rounded to the nearest integer.
+        """
+        return pulumi.get(self, "space_utilized_in_gbs")
+
+    @property
+    @pulumi.getter(name="timeAtWhichStorageDetailsAreUpdated")
+    def time_at_which_storage_details_are_updated(self) -> str:
+        """
+        The latest timestamp when the backup destination details, such as 'spaceUtilized,' are updated.
+        """
+        return pulumi.get(self, "time_at_which_storage_details_are_updated")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        Type of the database backup destination.
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter(name="vpcPassword")
+    def vpc_password(self) -> str:
+        """
+        For a RECOVERY_APPLIANCE backup destination, the password for the VPC user that is used to access the Recovery Appliance.
+        """
+        return pulumi.get(self, "vpc_password")
+
+    @property
+    @pulumi.getter(name="vpcUser")
+    def vpc_user(self) -> str:
+        """
+        For a RECOVERY_APPLIANCE backup destination, the Virtual Private Catalog (VPC) user that is used to access the Recovery Appliance.
+        """
+        return pulumi.get(self, "vpc_user")
+
+
 @pulumi.output_type
 class GetAutonomousContainerDatabasesAutonomousContainerDatabaseBackupConfigResult(dict):
     def __init__(__self__, *,
@@ -16923,7 +18220,7 @@ class GetAutonomousContainerDatabasesAutonomousContainerDatabaseBackupConfigResu
                  recovery_window_in_days: int):
         """
         :param Sequence['GetAutonomousContainerDatabasesAutonomousContainerDatabaseBackupConfigBackupDestinationDetailArgs'] backup_destination_details: Backup destination details.
-        :param int recovery_window_in_days: Number of days between the current and the earliest point of recoverability covered by automatic backups. This value applies to automatic backups. After a new automatic backup has been created, Oracle removes old automatic backups that are created before the window. When the value is updated, it is applied to all existing automatic backups. If the number of specified days is 0 then there will be no backups.
+        :param int recovery_window_in_days: Number of days between the current and earliest point of recoverability covered by automatic backups.
         """
         pulumi.set(__self__, "backup_destination_details", backup_destination_details)
         pulumi.set(__self__, "recovery_window_in_days", recovery_window_in_days)
@@ -16940,7 +18237,7 @@ class GetAutonomousContainerDatabasesAutonomousContainerDatabaseBackupConfigResu
     @pulumi.getter(name="recoveryWindowInDays")
     def recovery_window_in_days(self) -> int:
         """
-        Number of days between the current and the earliest point of recoverability covered by automatic backups. This value applies to automatic backups. After a new automatic backup has been created, Oracle removes old automatic backups that are created before the window. When the value is updated, it is applied to all existing automatic backups. If the number of specified days is 0 then there will be no backups.
+        Number of days between the current and earliest point of recoverability covered by automatic backups.
         """
         return pulumi.get(self, "recovery_window_in_days")
 
@@ -17007,6 +18304,46 @@ class GetAutonomousContainerDatabasesAutonomousContainerDatabaseBackupConfigBack
         return pulumi.get(self, "vpc_user")
 
 
+@pulumi.output_type
+class GetAutonomousContainerDatabasesAutonomousContainerDatabaseBackupDestinationPropertiesListResult(dict):
+    def __init__(__self__, *,
+                 backup_destination_attach_histories: Sequence[str],
+                 space_utilized_in_gbs: int,
+                 time_at_which_storage_details_are_updated: str):
+        """
+        :param Sequence[str] backup_destination_attach_histories: The timestamps at which this backup destination is used as the preferred destination to host the Autonomous Container Database backups.
+        :param int space_utilized_in_gbs: The total space utilized (in GBs) by this Autonomous Container Database on this backup destination, rounded to the nearest integer.
+        :param str time_at_which_storage_details_are_updated: The latest timestamp when the backup destination details, such as 'spaceUtilized,' are updated.
+        """
+        pulumi.set(__self__, "backup_destination_attach_histories", backup_destination_attach_histories)
+        pulumi.set(__self__, "space_utilized_in_gbs", space_utilized_in_gbs)
+        pulumi.set(__self__, "time_at_which_storage_details_are_updated", time_at_which_storage_details_are_updated)
+
+    @property
+    @pulumi.getter(name="backupDestinationAttachHistories")
+    def backup_destination_attach_histories(self) -> Sequence[str]:
+        """
+        The timestamps at which this backup destination is used as the preferred destination to host the Autonomous Container Database backups.
+        """
+        return pulumi.get(self, "backup_destination_attach_histories")
+
+    @property
+    @pulumi.getter(name="spaceUtilizedInGbs")
+    def space_utilized_in_gbs(self) -> int:
+        """
+        The total space utilized (in GBs) by this Autonomous Container Database on this backup destination, rounded to the nearest integer.
+        """
+        return pulumi.get(self, "space_utilized_in_gbs")
+
+    @property
+    @pulumi.getter(name="timeAtWhichStorageDetailsAreUpdated")
+    def time_at_which_storage_details_are_updated(self) -> str:
+        """
+        The latest timestamp when the backup destination details, such as 'spaceUtilized,' are updated.
+        """
+        return pulumi.get(self, "time_at_which_storage_details_are_updated")
+
+
 @pulumi.output_type
 class GetAutonomousContainerDatabasesAutonomousContainerDatabaseKeyHistoryEntryResult(dict):
     def __init__(__self__, *,
@@ -17397,7 +18734,7 @@ class GetAutonomousContainerDatabasesAutonomousContainerDatabasePeerAutonomousCo
                  recovery_window_in_days: int):
         """
         :param Sequence['GetAutonomousContainerDatabasesAutonomousContainerDatabasePeerAutonomousContainerDatabaseBackupConfigBackupDestinationDetailArgs'] backup_destination_details: Backup destination details.
-        :param int recovery_window_in_days: Number of days between the current and the earliest point of recoverability covered by automatic backups. This value applies to automatic backups. After a new automatic backup has been created, Oracle removes old automatic backups that are created before the window. When the value is updated, it is applied to all existing automatic backups. If the number of specified days is 0 then there will be no backups.
+        :param int recovery_window_in_days: Number of days between the current and earliest point of recoverability covered by automatic backups.
         """
         pulumi.set(__self__, "backup_destination_details", backup_destination_details)
         pulumi.set(__self__, "recovery_window_in_days", recovery_window_in_days)
@@ -17414,7 +18751,7 @@ class GetAutonomousContainerDatabasesAutonomousContainerDatabasePeerAutonomousCo
     @pulumi.getter(name="recoveryWindowInDays")
     def recovery_window_in_days(self) -> int:
         """
-        Number of days between the current and the earliest point of recoverability covered by automatic backups. This value applies to automatic backups. After a new automatic backup has been created, Oracle removes old automatic backups that are created before the window. When the value is updated, it is applied to all existing automatic backups. If the number of specified days is 0 then there will be no backups.
+        Number of days between the current and earliest point of recoverability covered by automatic backups.
         """
         return pulumi.get(self, "recovery_window_in_days")
 
@@ -17481,6 +18818,46 @@ class GetAutonomousContainerDatabasesAutonomousContainerDatabasePeerAutonomousCo
         return pulumi.get(self, "vpc_user")
 
 
+@pulumi.output_type
+class GetAutonomousContainerDatabasesAutonomousContainerDatabaseRecoveryApplianceDetailResult(dict):
+    def __init__(__self__, *,
+                 allocated_storage_size_in_gbs: int,
+                 recovery_window_in_days: int,
+                 time_recovery_appliance_details_updated: str):
+        """
+        :param int allocated_storage_size_in_gbs: The storage size of the backup destination allocated for an Autonomous Container Database to store backups on the recovery appliance, in GBs, rounded to the nearest integer.
+        :param int recovery_window_in_days: Number of days between the current and earliest point of recoverability covered by automatic backups.
+        :param str time_recovery_appliance_details_updated: The time when the recovery appliance details are updated.
+        """
+        pulumi.set(__self__, "allocated_storage_size_in_gbs", allocated_storage_size_in_gbs)
+        pulumi.set(__self__, "recovery_window_in_days", recovery_window_in_days)
+        pulumi.set(__self__, "time_recovery_appliance_details_updated", time_recovery_appliance_details_updated)
+
+    @property
+    @pulumi.getter(name="allocatedStorageSizeInGbs")
+    def allocated_storage_size_in_gbs(self) -> int:
+        """
+        The storage size of the backup destination allocated for an Autonomous Container Database to store backups on the recovery appliance, in GBs, rounded to the nearest integer.
+        """
+        return pulumi.get(self, "allocated_storage_size_in_gbs")
+
+    @property
+    @pulumi.getter(name="recoveryWindowInDays")
+    def recovery_window_in_days(self) -> int:
+        """
+        Number of days between the current and earliest point of recoverability covered by automatic backups.
+        """
+        return pulumi.get(self, "recovery_window_in_days")
+
+    @property
+    @pulumi.getter(name="timeRecoveryApplianceDetailsUpdated")
+    def time_recovery_appliance_details_updated(self) -> str:
+        """
+        The time when the recovery appliance details are updated.
+        """
+        return pulumi.get(self, "time_recovery_appliance_details_updated")
+
+
 @pulumi.output_type
 class GetAutonomousContainerDatabasesFilterResult(dict):
     def __init__(__self__, *,
@@ -19091,23 +20468,32 @@ class GetAutonomousDatabaseLocalStandbyDbResult(dict):
                  availability_domain: str,
                  lag_time_in_seconds: int,
                  lifecycle_details: str,
+                 maintenance_target_component: str,
                  state: str,
                  time_data_guard_role_changed: str,
-                 time_disaster_recovery_role_changed: str):
+                 time_disaster_recovery_role_changed: str,
+                 time_maintenance_begin: str,
+                 time_maintenance_end: str):
         """
         :param str availability_domain: The availability domain of a local Autonomous Data Guard standby database of an Autonomous Database Serverless instance.
         :param int lag_time_in_seconds: The amount of time, in seconds, that the data of the standby database lags the data of the primary database. Can be used to determine the potential data loss in the event of a failover.
         :param str lifecycle_details: Additional information about the current lifecycle state.
+        :param str maintenance_target_component: The component chosen for maintenance.
         :param str state: The current state of the Autonomous Database.
         :param str time_data_guard_role_changed: The date and time the Autonomous Data Guard role was switched for the Autonomous Database. For databases that have standbys in both the primary Data Guard region and a remote Data Guard standby region, this is the latest timestamp of either the database using the "primary" role in the primary Data Guard region, or database located in the remote Data Guard standby region.
         :param str time_disaster_recovery_role_changed: The date and time the Disaster Recovery role was switched for the standby Autonomous Database.
+        :param str time_maintenance_begin: The date and time when maintenance will begin.
+        :param str time_maintenance_end: The date and time when maintenance will end.
         """
         pulumi.set(__self__, "availability_domain", availability_domain)
         pulumi.set(__self__, "lag_time_in_seconds", lag_time_in_seconds)
         pulumi.set(__self__, "lifecycle_details", lifecycle_details)
+        pulumi.set(__self__, "maintenance_target_component", maintenance_target_component)
         pulumi.set(__self__, "state", state)
         pulumi.set(__self__, "time_data_guard_role_changed", time_data_guard_role_changed)
         pulumi.set(__self__, "time_disaster_recovery_role_changed", time_disaster_recovery_role_changed)
+        pulumi.set(__self__, "time_maintenance_begin", time_maintenance_begin)
+        pulumi.set(__self__, "time_maintenance_end", time_maintenance_end)
 
     @property
     @pulumi.getter(name="availabilityDomain")
@@ -19133,6 +20519,14 @@ class GetAutonomousDatabaseLocalStandbyDbResult(dict):
         """
         return pulumi.get(self, "lifecycle_details")
 
+    @property
+    @pulumi.getter(name="maintenanceTargetComponent")
+    def maintenance_target_component(self) -> str:
+        """
+        The component chosen for maintenance.
+        """
+        return pulumi.get(self, "maintenance_target_component")
+
     @property
     @pulumi.getter
     def state(self) -> str:
@@ -19157,6 +20551,22 @@ class GetAutonomousDatabaseLocalStandbyDbResult(dict):
         """
         return pulumi.get(self, "time_disaster_recovery_role_changed")
 
+    @property
+    @pulumi.getter(name="timeMaintenanceBegin")
+    def time_maintenance_begin(self) -> str:
+        """
+        The date and time when maintenance will begin.
+        """
+        return pulumi.get(self, "time_maintenance_begin")
+
+    @property
+    @pulumi.getter(name="timeMaintenanceEnd")
+    def time_maintenance_end(self) -> str:
+        """
+        The date and time when maintenance will end.
+        """
+        return pulumi.get(self, "time_maintenance_end")
+
 
 @pulumi.output_type
 class GetAutonomousDatabaseLongTermBackupScheduleResult(dict):
@@ -19775,23 +21185,32 @@ class GetAutonomousDatabaseStandbyDbResult(dict):
                  availability_domain: str,
                  lag_time_in_seconds: int,
                  lifecycle_details: str,
+                 maintenance_target_component: str,
                  state: str,
                  time_data_guard_role_changed: str,
-                 time_disaster_recovery_role_changed: str):
+                 time_disaster_recovery_role_changed: str,
+                 time_maintenance_begin: str,
+                 time_maintenance_end: str):
         """
         :param str availability_domain: The availability domain of a local Autonomous Data Guard standby database of an Autonomous Database Serverless instance.
         :param int lag_time_in_seconds: The amount of time, in seconds, that the data of the standby database lags the data of the primary database. Can be used to determine the potential data loss in the event of a failover.
         :param str lifecycle_details: Additional information about the current lifecycle state.
+        :param str maintenance_target_component: The component chosen for maintenance.
         :param str state: The current state of the Autonomous Database.
         :param str time_data_guard_role_changed: The date and time the Autonomous Data Guard role was switched for the Autonomous Database. For databases that have standbys in both the primary Data Guard region and a remote Data Guard standby region, this is the latest timestamp of either the database using the "primary" role in the primary Data Guard region, or database located in the remote Data Guard standby region.
         :param str time_disaster_recovery_role_changed: The date and time the Disaster Recovery role was switched for the standby Autonomous Database.
+        :param str time_maintenance_begin: The date and time when maintenance will begin.
+        :param str time_maintenance_end: The date and time when maintenance will end.
         """
         pulumi.set(__self__, "availability_domain", availability_domain)
         pulumi.set(__self__, "lag_time_in_seconds", lag_time_in_seconds)
         pulumi.set(__self__, "lifecycle_details", lifecycle_details)
+        pulumi.set(__self__, "maintenance_target_component", maintenance_target_component)
         pulumi.set(__self__, "state", state)
         pulumi.set(__self__, "time_data_guard_role_changed", time_data_guard_role_changed)
         pulumi.set(__self__, "time_disaster_recovery_role_changed", time_disaster_recovery_role_changed)
+        pulumi.set(__self__, "time_maintenance_begin", time_maintenance_begin)
+        pulumi.set(__self__, "time_maintenance_end", time_maintenance_end)
 
     @property
     @pulumi.getter(name="availabilityDomain")
@@ -19817,6 +21236,14 @@ class GetAutonomousDatabaseStandbyDbResult(dict):
         """
         return pulumi.get(self, "lifecycle_details")
 
+    @property
+    @pulumi.getter(name="maintenanceTargetComponent")
+    def maintenance_target_component(self) -> str:
+        """
+        The component chosen for maintenance.
+        """
+        return pulumi.get(self, "maintenance_target_component")
+
     @property
     @pulumi.getter
     def state(self) -> str:
@@ -19841,6 +21268,22 @@ class GetAutonomousDatabaseStandbyDbResult(dict):
         """
         return pulumi.get(self, "time_disaster_recovery_role_changed")
 
+    @property
+    @pulumi.getter(name="timeMaintenanceBegin")
+    def time_maintenance_begin(self) -> str:
+        """
+        The date and time when maintenance will begin.
+        """
+        return pulumi.get(self, "time_maintenance_begin")
+
+    @property
+    @pulumi.getter(name="timeMaintenanceEnd")
+    def time_maintenance_end(self) -> str:
+        """
+        The date and time when maintenance will end.
+        """
+        return pulumi.get(self, "time_maintenance_end")
+
 
 @pulumi.output_type
 class GetAutonomousDatabasesAutonomousDatabaseResult(dict):
@@ -19862,6 +21305,7 @@ class GetAutonomousDatabasesAutonomousDatabaseResult(dict):
                  backup_retention_period_in_days: int,
                  byol_compute_count_limit: float,
                  character_set: str,
+                 clone_table_space_lists: Sequence[int],
                  clone_type: str,
                  cluster_placement_group_id: str,
                  compartment_id: str,
@@ -19924,6 +21368,7 @@ class GetAutonomousDatabasesAutonomousDatabaseResult(dict):
                  local_disaster_recovery_type: str,
                  local_standby_dbs: Sequence['outputs.GetAutonomousDatabasesAutonomousDatabaseLocalStandbyDbResult'],
                  long_term_backup_schedules: Sequence['outputs.GetAutonomousDatabasesAutonomousDatabaseLongTermBackupScheduleResult'],
+                 maintenance_target_component: str,
                  max_cpu_core_count: int,
                  memory_per_oracle_compute_unit_in_gbs: int,
                  ncharacter_set: str,
@@ -20005,6 +21450,7 @@ class GetAutonomousDatabasesAutonomousDatabaseResult(dict):
         :param Sequence['GetAutonomousDatabasesAutonomousDatabaseBackupConfigArgs'] backup_configs: Autonomous Database configuration details for storing [manual backups](https://docs.oracle.com/en/cloud/paas/autonomous-database/adbsa/backup-restore.html#GUID-9035DFB8-4702-4CEB-8281-C2A303820809) in the [Object Storage](https://docs.cloud.oracle.com/iaas/Content/Object/Concepts/objectstorageoverview.htm) service.
         :param int backup_retention_period_in_days: Retention period, in days, for backups.
         :param str character_set: The character set for the autonomous database.  The default is AL32UTF8. Allowed values are:
+        :param Sequence[int] clone_table_space_lists: A list of the source Autonomous Database's table space number(s) used to create this partial clone from the backup.
         :param str cluster_placement_group_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the cluster placement group of the Autonomous Serverless Database.
         :param str compartment_id: The compartment [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
         :param float compute_count: Compute used by database tools.
@@ -20064,6 +21510,7 @@ class GetAutonomousDatabasesAutonomousDatabaseResult(dict):
         :param str local_disaster_recovery_type: Indicates the local disaster recovery (DR) type of the Autonomous Database Serverless instance. Autonomous Data Guard (ADG) DR type provides business critical DR with a faster recovery time objective (RTO) during failover or switchover. Backup-based DR type provides lower cost DR with a slower RTO during failover or switchover.
         :param Sequence['GetAutonomousDatabasesAutonomousDatabaseLocalStandbyDbArgs'] local_standby_dbs: Autonomous Data Guard standby database details.
         :param Sequence['GetAutonomousDatabasesAutonomousDatabaseLongTermBackupScheduleArgs'] long_term_backup_schedules: Details for the long-term backup schedule.
+        :param str maintenance_target_component: The component chosen for maintenance.
         :param int max_cpu_core_count: The number of Max OCPU cores to be made available to the autonomous database with auto scaling of cpu enabled.
         :param int memory_per_oracle_compute_unit_in_gbs: The amount of memory (in GBs) enabled per ECPU or OCPU.
         :param str ncharacter_set: The national character set for the autonomous database.  The default is AL16UTF16. Allowed values are: AL16UTF16 or UTF8.
@@ -20141,6 +21588,7 @@ class GetAutonomousDatabasesAutonomousDatabaseResult(dict):
         pulumi.set(__self__, "backup_retention_period_in_days", backup_retention_period_in_days)
         pulumi.set(__self__, "byol_compute_count_limit", byol_compute_count_limit)
         pulumi.set(__self__, "character_set", character_set)
+        pulumi.set(__self__, "clone_table_space_lists", clone_table_space_lists)
         pulumi.set(__self__, "clone_type", clone_type)
         pulumi.set(__self__, "cluster_placement_group_id", cluster_placement_group_id)
         pulumi.set(__self__, "compartment_id", compartment_id)
@@ -20203,6 +21651,7 @@ class GetAutonomousDatabasesAutonomousDatabaseResult(dict):
         pulumi.set(__self__, "local_disaster_recovery_type", local_disaster_recovery_type)
         pulumi.set(__self__, "local_standby_dbs", local_standby_dbs)
         pulumi.set(__self__, "long_term_backup_schedules", long_term_backup_schedules)
+        pulumi.set(__self__, "maintenance_target_component", maintenance_target_component)
         pulumi.set(__self__, "max_cpu_core_count", max_cpu_core_count)
         pulumi.set(__self__, "memory_per_oracle_compute_unit_in_gbs", memory_per_oracle_compute_unit_in_gbs)
         pulumi.set(__self__, "ncharacter_set", ncharacter_set)
@@ -20395,6 +21844,14 @@ class GetAutonomousDatabasesAutonomousDatabaseResult(dict):
         """
         return pulumi.get(self, "character_set")
 
+    @property
+    @pulumi.getter(name="cloneTableSpaceLists")
+    def clone_table_space_lists(self) -> Sequence[int]:
+        """
+        A list of the source Autonomous Database's table space number(s) used to create this partial clone from the backup.
+        """
+        return pulumi.get(self, "clone_table_space_lists")
+
     @property
     @pulumi.getter(name="cloneType")
     def clone_type(self) -> str:
@@ -20881,6 +22338,14 @@ class GetAutonomousDatabasesAutonomousDatabaseResult(dict):
         """
         return pulumi.get(self, "long_term_backup_schedules")
 
+    @property
+    @pulumi.getter(name="maintenanceTargetComponent")
+    def maintenance_target_component(self) -> str:
+        """
+        The component chosen for maintenance.
+        """
+        return pulumi.get(self, "maintenance_target_component")
+
     @property
     @pulumi.getter(name="maxCpuCoreCount")
     def max_cpu_core_count(self) -> int:
@@ -22195,23 +23660,32 @@ class GetAutonomousDatabasesAutonomousDatabaseLocalStandbyDbResult(dict):
                  availability_domain: str,
                  lag_time_in_seconds: int,
                  lifecycle_details: str,
+                 maintenance_target_component: str,
                  state: str,
                  time_data_guard_role_changed: str,
-                 time_disaster_recovery_role_changed: str):
+                 time_disaster_recovery_role_changed: str,
+                 time_maintenance_begin: str,
+                 time_maintenance_end: str):
         """
         :param str availability_domain: The availability domain of a local Autonomous Data Guard standby database of an Autonomous Database Serverless instance.
         :param int lag_time_in_seconds: The amount of time, in seconds, that the data of the standby database lags the data of the primary database. Can be used to determine the potential data loss in the event of a failover.
         :param str lifecycle_details: Additional information about the current lifecycle state.
+        :param str maintenance_target_component: The component chosen for maintenance.
         :param str state: A filter to return only resources that match the given lifecycle state exactly.
         :param str time_data_guard_role_changed: The date and time the Autonomous Data Guard role was switched for the Autonomous Database. For databases that have standbys in both the primary Data Guard region and a remote Data Guard standby region, this is the latest timestamp of either the database using the "primary" role in the primary Data Guard region, or database located in the remote Data Guard standby region.
         :param str time_disaster_recovery_role_changed: The date and time the Disaster Recovery role was switched for the standby Autonomous Database.
+        :param str time_maintenance_begin: The date and time when maintenance will begin.
+        :param str time_maintenance_end: The date and time when maintenance will end.
         """
         pulumi.set(__self__, "availability_domain", availability_domain)
         pulumi.set(__self__, "lag_time_in_seconds", lag_time_in_seconds)
         pulumi.set(__self__, "lifecycle_details", lifecycle_details)
+        pulumi.set(__self__, "maintenance_target_component", maintenance_target_component)
         pulumi.set(__self__, "state", state)
         pulumi.set(__self__, "time_data_guard_role_changed", time_data_guard_role_changed)
         pulumi.set(__self__, "time_disaster_recovery_role_changed", time_disaster_recovery_role_changed)
+        pulumi.set(__self__, "time_maintenance_begin", time_maintenance_begin)
+        pulumi.set(__self__, "time_maintenance_end", time_maintenance_end)
 
     @property
     @pulumi.getter(name="availabilityDomain")
@@ -22237,6 +23711,14 @@ class GetAutonomousDatabasesAutonomousDatabaseLocalStandbyDbResult(dict):
         """
         return pulumi.get(self, "lifecycle_details")
 
+    @property
+    @pulumi.getter(name="maintenanceTargetComponent")
+    def maintenance_target_component(self) -> str:
+        """
+        The component chosen for maintenance.
+        """
+        return pulumi.get(self, "maintenance_target_component")
+
     @property
     @pulumi.getter
     def state(self) -> str:
@@ -22261,6 +23743,22 @@ class GetAutonomousDatabasesAutonomousDatabaseLocalStandbyDbResult(dict):
         """
         return pulumi.get(self, "time_disaster_recovery_role_changed")
 
+    @property
+    @pulumi.getter(name="timeMaintenanceBegin")
+    def time_maintenance_begin(self) -> str:
+        """
+        The date and time when maintenance will begin.
+        """
+        return pulumi.get(self, "time_maintenance_begin")
+
+    @property
+    @pulumi.getter(name="timeMaintenanceEnd")
+    def time_maintenance_end(self) -> str:
+        """
+        The date and time when maintenance will end.
+        """
+        return pulumi.get(self, "time_maintenance_end")
+
 
 @pulumi.output_type
 class GetAutonomousDatabasesAutonomousDatabaseLongTermBackupScheduleResult(dict):
@@ -22552,23 +24050,32 @@ class GetAutonomousDatabasesAutonomousDatabaseStandbyDbResult(dict):
                  availability_domain: str,
                  lag_time_in_seconds: int,
                  lifecycle_details: str,
+                 maintenance_target_component: str,
                  state: str,
                  time_data_guard_role_changed: str,
-                 time_disaster_recovery_role_changed: str):
+                 time_disaster_recovery_role_changed: str,
+                 time_maintenance_begin: str,
+                 time_maintenance_end: str):
         """
         :param str availability_domain: The availability domain of a local Autonomous Data Guard standby database of an Autonomous Database Serverless instance.
         :param int lag_time_in_seconds: The amount of time, in seconds, that the data of the standby database lags the data of the primary database. Can be used to determine the potential data loss in the event of a failover.
         :param str lifecycle_details: Additional information about the current lifecycle state.
+        :param str maintenance_target_component: The component chosen for maintenance.
         :param str state: A filter to return only resources that match the given lifecycle state exactly.
         :param str time_data_guard_role_changed: The date and time the Autonomous Data Guard role was switched for the Autonomous Database. For databases that have standbys in both the primary Data Guard region and a remote Data Guard standby region, this is the latest timestamp of either the database using the "primary" role in the primary Data Guard region, or database located in the remote Data Guard standby region.
         :param str time_disaster_recovery_role_changed: The date and time the Disaster Recovery role was switched for the standby Autonomous Database.
+        :param str time_maintenance_begin: The date and time when maintenance will begin.
+        :param str time_maintenance_end: The date and time when maintenance will end.
         """
         pulumi.set(__self__, "availability_domain", availability_domain)
         pulumi.set(__self__, "lag_time_in_seconds", lag_time_in_seconds)
         pulumi.set(__self__, "lifecycle_details", lifecycle_details)
+        pulumi.set(__self__, "maintenance_target_component", maintenance_target_component)
         pulumi.set(__self__, "state", state)
         pulumi.set(__self__, "time_data_guard_role_changed", time_data_guard_role_changed)
         pulumi.set(__self__, "time_disaster_recovery_role_changed", time_disaster_recovery_role_changed)
+        pulumi.set(__self__, "time_maintenance_begin", time_maintenance_begin)
+        pulumi.set(__self__, "time_maintenance_end", time_maintenance_end)
 
     @property
     @pulumi.getter(name="availabilityDomain")
@@ -22594,6 +24101,14 @@ class GetAutonomousDatabasesAutonomousDatabaseStandbyDbResult(dict):
         """
         return pulumi.get(self, "lifecycle_details")
 
+    @property
+    @pulumi.getter(name="maintenanceTargetComponent")
+    def maintenance_target_component(self) -> str:
+        """
+        The component chosen for maintenance.
+        """
+        return pulumi.get(self, "maintenance_target_component")
+
     @property
     @pulumi.getter
     def state(self) -> str:
@@ -22618,6 +24133,22 @@ class GetAutonomousDatabasesAutonomousDatabaseStandbyDbResult(dict):
         """
         return pulumi.get(self, "time_disaster_recovery_role_changed")
 
+    @property
+    @pulumi.getter(name="timeMaintenanceBegin")
+    def time_maintenance_begin(self) -> str:
+        """
+        The date and time when maintenance will begin.
+        """
+        return pulumi.get(self, "time_maintenance_begin")
+
+    @property
+    @pulumi.getter(name="timeMaintenanceEnd")
+    def time_maintenance_end(self) -> str:
+        """
+        The date and time when maintenance will end.
+        """
+        return pulumi.get(self, "time_maintenance_end")
+
 
 @pulumi.output_type
 class GetAutonomousDatabasesClonesAutonomousDatabaseResult(dict):
@@ -22636,6 +24167,7 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseResult(dict):
                  backup_retention_period_in_days: int,
                  byol_compute_count_limit: float,
                  character_set: str,
+                 clone_table_space_lists: Sequence[int],
                  cluster_placement_group_id: str,
                  compartment_id: str,
                  compute_count: float,
@@ -22691,6 +24223,7 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseResult(dict):
                  local_disaster_recovery_type: str,
                  local_standby_dbs: Sequence['outputs.GetAutonomousDatabasesClonesAutonomousDatabaseLocalStandbyDbResult'],
                  long_term_backup_schedules: Sequence['outputs.GetAutonomousDatabasesClonesAutonomousDatabaseLongTermBackupScheduleResult'],
+                 maintenance_target_component: str,
                  max_cpu_core_count: int,
                  memory_per_oracle_compute_unit_in_gbs: int,
                  ncharacter_set: str,
@@ -22758,6 +24291,7 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseResult(dict):
         :param Sequence['GetAutonomousDatabasesClonesAutonomousDatabaseBackupConfigArgs'] backup_configs: Autonomous Database configuration details for storing [manual backups](https://docs.oracle.com/en/cloud/paas/autonomous-database/adbsa/backup-restore.html#GUID-9035DFB8-4702-4CEB-8281-C2A303820809) in the [Object Storage](https://docs.cloud.oracle.com/iaas/Content/Object/Concepts/objectstorageoverview.htm) service.
         :param int backup_retention_period_in_days: Retention period, in days, for backups.
         :param str character_set: The character set for the autonomous database.  The default is AL32UTF8. Allowed values are:
+        :param Sequence[int] clone_table_space_lists: A list of the source Autonomous Database's table space number(s) used to create this partial clone from the backup.
         :param str cluster_placement_group_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the cluster placement group of the Autonomous Serverless Database.
         :param str compartment_id: The compartment [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
         :param float compute_count: Compute used by database tools.
@@ -22817,6 +24351,7 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseResult(dict):
         :param str local_disaster_recovery_type: Indicates the local disaster recovery (DR) type of the Autonomous Database Serverless instance. Autonomous Data Guard (ADG) DR type provides business critical DR with a faster recovery time objective (RTO) during failover or switchover. Backup-based DR type provides lower cost DR with a slower RTO during failover or switchover.
         :param Sequence['GetAutonomousDatabasesClonesAutonomousDatabaseLocalStandbyDbArgs'] local_standby_dbs: Autonomous Data Guard standby database details.* `availability_domain` - The availability domain of a local Autonomous Data Guard standby database of an Autonomous Database Serverless instance.
         :param Sequence['GetAutonomousDatabasesClonesAutonomousDatabaseLongTermBackupScheduleArgs'] long_term_backup_schedules: Details for the long-term backup schedule.
+        :param str maintenance_target_component: The component chosen for maintenance.
         :param int max_cpu_core_count: The number of Max OCPU cores to be made available to the autonomous database with auto scaling of cpu enabled.
         :param int memory_per_oracle_compute_unit_in_gbs: The amount of memory (in GBs) enabled per OCPU or ECPU. See [Compute Models in Autonomous Database on Dedicated Exadata Infrastructure](https://docs.oracle.com/en/cloud/paas/autonomous-database/dedicated/adbak) for more details.
         :param str ncharacter_set: The national character set for the autonomous database.  The default is AL16UTF16. Allowed values are: AL16UTF16 or UTF8.
@@ -22889,6 +24424,7 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseResult(dict):
         pulumi.set(__self__, "backup_retention_period_in_days", backup_retention_period_in_days)
         pulumi.set(__self__, "byol_compute_count_limit", byol_compute_count_limit)
         pulumi.set(__self__, "character_set", character_set)
+        pulumi.set(__self__, "clone_table_space_lists", clone_table_space_lists)
         pulumi.set(__self__, "cluster_placement_group_id", cluster_placement_group_id)
         pulumi.set(__self__, "compartment_id", compartment_id)
         pulumi.set(__self__, "compute_count", compute_count)
@@ -22944,6 +24480,7 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseResult(dict):
         pulumi.set(__self__, "local_disaster_recovery_type", local_disaster_recovery_type)
         pulumi.set(__self__, "local_standby_dbs", local_standby_dbs)
         pulumi.set(__self__, "long_term_backup_schedules", long_term_backup_schedules)
+        pulumi.set(__self__, "maintenance_target_component", maintenance_target_component)
         pulumi.set(__self__, "max_cpu_core_count", max_cpu_core_count)
         pulumi.set(__self__, "memory_per_oracle_compute_unit_in_gbs", memory_per_oracle_compute_unit_in_gbs)
         pulumi.set(__self__, "ncharacter_set", ncharacter_set)
@@ -23105,6 +24642,14 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseResult(dict):
         """
         return pulumi.get(self, "character_set")
 
+    @property
+    @pulumi.getter(name="cloneTableSpaceLists")
+    def clone_table_space_lists(self) -> Sequence[int]:
+        """
+        A list of the source Autonomous Database's table space number(s) used to create this partial clone from the backup.
+        """
+        return pulumi.get(self, "clone_table_space_lists")
+
     @property
     @pulumi.getter(name="clusterPlacementGroupId")
     def cluster_placement_group_id(self) -> str:
@@ -23549,6 +25094,14 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseResult(dict):
         """
         return pulumi.get(self, "long_term_backup_schedules")
 
+    @property
+    @pulumi.getter(name="maintenanceTargetComponent")
+    def maintenance_target_component(self) -> str:
+        """
+        The component chosen for maintenance.
+        """
+        return pulumi.get(self, "maintenance_target_component")
+
     @property
     @pulumi.getter(name="maxCpuCoreCount")
     def max_cpu_core_count(self) -> int:
@@ -24792,22 +26345,31 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseLocalStandbyDbResult(dict):
                  availability_domain: str,
                  lag_time_in_seconds: int,
                  lifecycle_details: str,
+                 maintenance_target_component: str,
                  state: str,
                  time_data_guard_role_changed: str,
-                 time_disaster_recovery_role_changed: str):
+                 time_disaster_recovery_role_changed: str,
+                 time_maintenance_begin: str,
+                 time_maintenance_end: str):
         """
         :param int lag_time_in_seconds: The amount of time, in seconds, that the data of the standby database lags the data of the primary database. Can be used to determine the potential data loss in the event of a failover.
         :param str lifecycle_details: Additional information about the current lifecycle state.
+        :param str maintenance_target_component: The component chosen for maintenance.
         :param str state: A filter to return only resources that match the given lifecycle state exactly.
         :param str time_data_guard_role_changed: The date and time the Autonomous Data Guard role was switched for the Autonomous Database. For databases that have standbys in both the primary Data Guard region and a remote Data Guard standby region, this is the latest timestamp of either the database using the "primary" role in the primary Data Guard region, or database located in the remote Data Guard standby region.
         :param str time_disaster_recovery_role_changed: The date and time the Disaster Recovery role was switched for the standby Autonomous Database.
+        :param str time_maintenance_begin: The date and time when maintenance will begin.
+        :param str time_maintenance_end: The date and time when maintenance will end.
         """
         pulumi.set(__self__, "availability_domain", availability_domain)
         pulumi.set(__self__, "lag_time_in_seconds", lag_time_in_seconds)
         pulumi.set(__self__, "lifecycle_details", lifecycle_details)
+        pulumi.set(__self__, "maintenance_target_component", maintenance_target_component)
         pulumi.set(__self__, "state", state)
         pulumi.set(__self__, "time_data_guard_role_changed", time_data_guard_role_changed)
         pulumi.set(__self__, "time_disaster_recovery_role_changed", time_disaster_recovery_role_changed)
+        pulumi.set(__self__, "time_maintenance_begin", time_maintenance_begin)
+        pulumi.set(__self__, "time_maintenance_end", time_maintenance_end)
 
     @property
     @pulumi.getter(name="availabilityDomain")
@@ -24830,6 +26392,14 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseLocalStandbyDbResult(dict):
         """
         return pulumi.get(self, "lifecycle_details")
 
+    @property
+    @pulumi.getter(name="maintenanceTargetComponent")
+    def maintenance_target_component(self) -> str:
+        """
+        The component chosen for maintenance.
+        """
+        return pulumi.get(self, "maintenance_target_component")
+
     @property
     @pulumi.getter
     def state(self) -> str:
@@ -24854,6 +26424,22 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseLocalStandbyDbResult(dict):
         """
         return pulumi.get(self, "time_disaster_recovery_role_changed")
 
+    @property
+    @pulumi.getter(name="timeMaintenanceBegin")
+    def time_maintenance_begin(self) -> str:
+        """
+        The date and time when maintenance will begin.
+        """
+        return pulumi.get(self, "time_maintenance_begin")
+
+    @property
+    @pulumi.getter(name="timeMaintenanceEnd")
+    def time_maintenance_end(self) -> str:
+        """
+        The date and time when maintenance will end.
+        """
+        return pulumi.get(self, "time_maintenance_end")
+
 
 @pulumi.output_type
 class GetAutonomousDatabasesClonesAutonomousDatabaseLongTermBackupScheduleResult(dict):
@@ -25141,22 +26727,31 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseStandbyDbResult(dict):
                  availability_domain: str,
                  lag_time_in_seconds: int,
                  lifecycle_details: str,
+                 maintenance_target_component: str,
                  state: str,
                  time_data_guard_role_changed: str,
-                 time_disaster_recovery_role_changed: str):
+                 time_disaster_recovery_role_changed: str,
+                 time_maintenance_begin: str,
+                 time_maintenance_end: str):
         """
         :param int lag_time_in_seconds: The amount of time, in seconds, that the data of the standby database lags the data of the primary database. Can be used to determine the potential data loss in the event of a failover.
         :param str lifecycle_details: Additional information about the current lifecycle state.
+        :param str maintenance_target_component: The component chosen for maintenance.
         :param str state: A filter to return only resources that match the given lifecycle state exactly.
         :param str time_data_guard_role_changed: The date and time the Autonomous Data Guard role was switched for the Autonomous Database. For databases that have standbys in both the primary Data Guard region and a remote Data Guard standby region, this is the latest timestamp of either the database using the "primary" role in the primary Data Guard region, or database located in the remote Data Guard standby region.
         :param str time_disaster_recovery_role_changed: The date and time the Disaster Recovery role was switched for the standby Autonomous Database.
+        :param str time_maintenance_begin: The date and time when maintenance will begin.
+        :param str time_maintenance_end: The date and time when maintenance will end.
         """
         pulumi.set(__self__, "availability_domain", availability_domain)
         pulumi.set(__self__, "lag_time_in_seconds", lag_time_in_seconds)
         pulumi.set(__self__, "lifecycle_details", lifecycle_details)
+        pulumi.set(__self__, "maintenance_target_component", maintenance_target_component)
         pulumi.set(__self__, "state", state)
         pulumi.set(__self__, "time_data_guard_role_changed", time_data_guard_role_changed)
         pulumi.set(__self__, "time_disaster_recovery_role_changed", time_disaster_recovery_role_changed)
+        pulumi.set(__self__, "time_maintenance_begin", time_maintenance_begin)
+        pulumi.set(__self__, "time_maintenance_end", time_maintenance_end)
 
     @property
     @pulumi.getter(name="availabilityDomain")
@@ -25179,6 +26774,14 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseStandbyDbResult(dict):
         """
         return pulumi.get(self, "lifecycle_details")
 
+    @property
+    @pulumi.getter(name="maintenanceTargetComponent")
+    def maintenance_target_component(self) -> str:
+        """
+        The component chosen for maintenance.
+        """
+        return pulumi.get(self, "maintenance_target_component")
+
     @property
     @pulumi.getter
     def state(self) -> str:
@@ -25203,6 +26806,22 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseStandbyDbResult(dict):
         """
         return pulumi.get(self, "time_disaster_recovery_role_changed")
 
+    @property
+    @pulumi.getter(name="timeMaintenanceBegin")
+    def time_maintenance_begin(self) -> str:
+        """
+        The date and time when maintenance will begin.
+        """
+        return pulumi.get(self, "time_maintenance_begin")
+
+    @property
+    @pulumi.getter(name="timeMaintenanceEnd")
+    def time_maintenance_end(self) -> str:
+        """
+        The date and time when maintenance will end.
+        """
+        return pulumi.get(self, "time_maintenance_end")
+
 
 @pulumi.output_type
 class GetAutonomousDatabasesClonesFilterResult(dict):
@@ -28406,8 +30025,11 @@ class GetBackupDestinationsBackupDestinationResult(dict):
                  nfs_server_export: str,
                  nfs_servers: Sequence[str],
                  state: str,
+                 time_at_which_storage_details_are_updated: str,
                  time_created: str,
+                 total_storage_size_in_gbs: int,
                  type: str,
+                 utilized_storage_size_in_gbs: int,
                  vpc_users: Sequence[str]):
         """
         :param Sequence['GetBackupDestinationsBackupDestinationAssociatedDatabaseArgs'] associated_databases: List of databases associated with the backup destination.
@@ -28423,8 +30045,11 @@ class GetBackupDestinationsBackupDestinationResult(dict):
         :param str nfs_server_export: Specifies the directory on which to mount the file system
         :param Sequence[str] nfs_servers: Host names or IP addresses for NFS Auto mount.
         :param str state: The current lifecycle state of the backup destination.
+        :param str time_at_which_storage_details_are_updated: The time when the total storage size and the utilized storage size of the backup destination are updated.
         :param str time_created: The date and time the backup destination was created.
+        :param int total_storage_size_in_gbs: The total storage size of the backup destination in GBs, rounded to the nearest integer.
         :param str type: A filter to return only resources that match the given type of the Backup Destination.
+        :param int utilized_storage_size_in_gbs: The total amount of space utilized on the backup destination (in GBs), rounded to the nearest integer.
         :param Sequence[str] vpc_users: For a RECOVERY_APPLIANCE backup destination, the Virtual Private Catalog (VPC) users that are used to access the Recovery Appliance.
         """
         pulumi.set(__self__, "associated_databases", associated_databases)
@@ -28441,8 +30066,11 @@ class GetBackupDestinationsBackupDestinationResult(dict):
         pulumi.set(__self__, "nfs_server_export", nfs_server_export)
         pulumi.set(__self__, "nfs_servers", nfs_servers)
         pulumi.set(__self__, "state", state)
+        pulumi.set(__self__, "time_at_which_storage_details_are_updated", time_at_which_storage_details_are_updated)
         pulumi.set(__self__, "time_created", time_created)
+        pulumi.set(__self__, "total_storage_size_in_gbs", total_storage_size_in_gbs)
         pulumi.set(__self__, "type", type)
+        pulumi.set(__self__, "utilized_storage_size_in_gbs", utilized_storage_size_in_gbs)
         pulumi.set(__self__, "vpc_users", vpc_users)
 
     @property
@@ -28555,6 +30183,14 @@ class GetBackupDestinationsBackupDestinationResult(dict):
         """
         return pulumi.get(self, "state")
 
+    @property
+    @pulumi.getter(name="timeAtWhichStorageDetailsAreUpdated")
+    def time_at_which_storage_details_are_updated(self) -> str:
+        """
+        The time when the total storage size and the utilized storage size of the backup destination are updated.
+        """
+        return pulumi.get(self, "time_at_which_storage_details_are_updated")
+
     @property
     @pulumi.getter(name="timeCreated")
     def time_created(self) -> str:
@@ -28563,6 +30199,14 @@ class GetBackupDestinationsBackupDestinationResult(dict):
         """
         return pulumi.get(self, "time_created")
 
+    @property
+    @pulumi.getter(name="totalStorageSizeInGbs")
+    def total_storage_size_in_gbs(self) -> int:
+        """
+        The total storage size of the backup destination in GBs, rounded to the nearest integer.
+        """
+        return pulumi.get(self, "total_storage_size_in_gbs")
+
     @property
     @pulumi.getter
     def type(self) -> str:
@@ -28571,6 +30215,14 @@ class GetBackupDestinationsBackupDestinationResult(dict):
         """
         return pulumi.get(self, "type")
 
+    @property
+    @pulumi.getter(name="utilizedStorageSizeInGbs")
+    def utilized_storage_size_in_gbs(self) -> int:
+        """
+        The total amount of space utilized on the backup destination (in GBs), rounded to the nearest integer.
+        """
+        return pulumi.get(self, "utilized_storage_size_in_gbs")
+
     @property
     @pulumi.getter(name="vpcUsers")
     def vpc_users(self) -> Sequence[str]:
@@ -28687,6 +30339,7 @@ class GetBackupDestinationsFilterResult(dict):
 class GetBackupsBackupResult(dict):
     def __init__(__self__, *,
                  availability_domain: str,
+                 backup_destination_type: str,
                  compartment_id: str,
                  database_edition: str,
                  database_id: str,
@@ -28694,41 +30347,53 @@ class GetBackupsBackupResult(dict):
                  display_name: str,
                  encryption_key_location_details: Sequence['outputs.GetBackupsBackupEncryptionKeyLocationDetailResult'],
                  id: str,
+                 is_using_oracle_managed_keys: bool,
                  key_store_id: str,
                  key_store_wallet_name: str,
                  kms_key_id: str,
                  kms_key_version_id: str,
                  lifecycle_details: str,
+                 retention_period_in_days: int,
+                 retention_period_in_years: int,
+                 secondary_kms_key_ids: Sequence[str],
                  shape: str,
                  state: str,
                  time_ended: str,
+                 time_expiry_scheduled: str,
                  time_started: str,
                  type: str,
                  vault_id: str,
                  version: str):
         """
         :param str availability_domain: The name of the availability domain where the database backup is stored.
+        :param str backup_destination_type: A filter to return only resources that match the given backup destination type.
         :param str compartment_id: The compartment [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
-        :param str database_edition: The Oracle Database edition of the DB system from which the database backup was taken.
+        :param str database_edition: The Oracle Database Edition that applies to all the databases on the DB system. Exadata DB systems and 2-node RAC DB systems require ENTERPRISE_EDITION_EXTREME_PERFORMANCE.
         :param str database_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the database.
         :param float database_size_in_gbs: The size of the database in gigabytes at the time the backup was taken.
         :param str display_name: The user-friendly name for the backup. The name does not have to be unique.
         :param Sequence['GetBackupsBackupEncryptionKeyLocationDetailArgs'] encryption_key_location_details: Types of providers supported for managing database encryption keys
         :param str id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the backup.
+        :param bool is_using_oracle_managed_keys: True if Oracle Managed Keys is required for restore of the backup.
         :param str key_store_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the key store of Oracle Vault.
         :param str key_store_wallet_name: The wallet name for Oracle Key Vault.
         :param str kms_key_id: The OCID of the key container that is used as the master encryption key in database transparent data encryption (TDE) operations.
         :param str kms_key_version_id: The OCID of the key container version that is used in database transparent data encryption (TDE) operations KMS Key can have multiple key versions. If none is specified, the current key version (latest) of the Key Id is used for the operation. Autonomous Database Serverless does not use key versions, hence is not applicable for Autonomous Database Serverless instances.
         :param str lifecycle_details: Additional information about the current lifecycle state.
+        :param int retention_period_in_days: The retention period of the long term backup in days.
+        :param int retention_period_in_years: The retention period of the long term backup in years.
+        :param Sequence[str] secondary_kms_key_ids: List of OCIDs of the key containers used as the secondary encryption key in database transparent data encryption (TDE) operations.
         :param str shape: Shape of the backup's source database.
-        :param str state: The current state of the backup.
+        :param str state: A filter to return only resources that match the given lifecycle state exactly.
         :param str time_ended: The date and time the backup was completed.
+        :param str time_expiry_scheduled: Expiration time of the long term database backup.
         :param str time_started: The date and time the backup started.
-        :param str type: The type of backup.
+        :param str type: A filter to return only backups that matches with the given type of Backup.
         :param str vault_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Oracle Cloud Infrastructure [vault](https://docs.cloud.oracle.com/iaas/Content/KeyManagement/Concepts/keyoverview.htm#concepts). This parameter and `secretId` are required for Customer Managed Keys.
-        :param str version: Version of the backup's source database
+        :param str version: A filter to return only resources that match the given database version.
         """
         pulumi.set(__self__, "availability_domain", availability_domain)
+        pulumi.set(__self__, "backup_destination_type", backup_destination_type)
         pulumi.set(__self__, "compartment_id", compartment_id)
         pulumi.set(__self__, "database_edition", database_edition)
         pulumi.set(__self__, "database_id", database_id)
@@ -28736,14 +30401,19 @@ class GetBackupsBackupResult(dict):
         pulumi.set(__self__, "display_name", display_name)
         pulumi.set(__self__, "encryption_key_location_details", encryption_key_location_details)
         pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "is_using_oracle_managed_keys", is_using_oracle_managed_keys)
         pulumi.set(__self__, "key_store_id", key_store_id)
         pulumi.set(__self__, "key_store_wallet_name", key_store_wallet_name)
         pulumi.set(__self__, "kms_key_id", kms_key_id)
         pulumi.set(__self__, "kms_key_version_id", kms_key_version_id)
         pulumi.set(__self__, "lifecycle_details", lifecycle_details)
+        pulumi.set(__self__, "retention_period_in_days", retention_period_in_days)
+        pulumi.set(__self__, "retention_period_in_years", retention_period_in_years)
+        pulumi.set(__self__, "secondary_kms_key_ids", secondary_kms_key_ids)
         pulumi.set(__self__, "shape", shape)
         pulumi.set(__self__, "state", state)
         pulumi.set(__self__, "time_ended", time_ended)
+        pulumi.set(__self__, "time_expiry_scheduled", time_expiry_scheduled)
         pulumi.set(__self__, "time_started", time_started)
         pulumi.set(__self__, "type", type)
         pulumi.set(__self__, "vault_id", vault_id)
@@ -28757,6 +30427,14 @@ class GetBackupsBackupResult(dict):
         """
         return pulumi.get(self, "availability_domain")
 
+    @property
+    @pulumi.getter(name="backupDestinationType")
+    def backup_destination_type(self) -> str:
+        """
+        A filter to return only resources that match the given backup destination type.
+        """
+        return pulumi.get(self, "backup_destination_type")
+
     @property
     @pulumi.getter(name="compartmentId")
     def compartment_id(self) -> str:
@@ -28769,7 +30447,7 @@ class GetBackupsBackupResult(dict):
     @pulumi.getter(name="databaseEdition")
     def database_edition(self) -> str:
         """
-        The Oracle Database edition of the DB system from which the database backup was taken.
+        The Oracle Database Edition that applies to all the databases on the DB system. Exadata DB systems and 2-node RAC DB systems require ENTERPRISE_EDITION_EXTREME_PERFORMANCE.
         """
         return pulumi.get(self, "database_edition")
 
@@ -28813,6 +30491,14 @@ class GetBackupsBackupResult(dict):
         """
         return pulumi.get(self, "id")
 
+    @property
+    @pulumi.getter(name="isUsingOracleManagedKeys")
+    def is_using_oracle_managed_keys(self) -> bool:
+        """
+        True if Oracle Managed Keys is required for restore of the backup.
+        """
+        return pulumi.get(self, "is_using_oracle_managed_keys")
+
     @property
     @pulumi.getter(name="keyStoreId")
     def key_store_id(self) -> str:
@@ -28853,6 +30539,30 @@ class GetBackupsBackupResult(dict):
         """
         return pulumi.get(self, "lifecycle_details")
 
+    @property
+    @pulumi.getter(name="retentionPeriodInDays")
+    def retention_period_in_days(self) -> int:
+        """
+        The retention period of the long term backup in days.
+        """
+        return pulumi.get(self, "retention_period_in_days")
+
+    @property
+    @pulumi.getter(name="retentionPeriodInYears")
+    def retention_period_in_years(self) -> int:
+        """
+        The retention period of the long term backup in years.
+        """
+        return pulumi.get(self, "retention_period_in_years")
+
+    @property
+    @pulumi.getter(name="secondaryKmsKeyIds")
+    def secondary_kms_key_ids(self) -> Sequence[str]:
+        """
+        List of OCIDs of the key containers used as the secondary encryption key in database transparent data encryption (TDE) operations.
+        """
+        return pulumi.get(self, "secondary_kms_key_ids")
+
     @property
     @pulumi.getter
     def shape(self) -> str:
@@ -28865,7 +30575,7 @@ class GetBackupsBackupResult(dict):
     @pulumi.getter
     def state(self) -> str:
         """
-        The current state of the backup.
+        A filter to return only resources that match the given lifecycle state exactly.
         """
         return pulumi.get(self, "state")
 
@@ -28877,6 +30587,14 @@ class GetBackupsBackupResult(dict):
         """
         return pulumi.get(self, "time_ended")
 
+    @property
+    @pulumi.getter(name="timeExpiryScheduled")
+    def time_expiry_scheduled(self) -> str:
+        """
+        Expiration time of the long term database backup.
+        """
+        return pulumi.get(self, "time_expiry_scheduled")
+
     @property
     @pulumi.getter(name="timeStarted")
     def time_started(self) -> str:
@@ -28889,7 +30607,7 @@ class GetBackupsBackupResult(dict):
     @pulumi.getter
     def type(self) -> str:
         """
-        The type of backup.
+        A filter to return only backups that matches with the given type of Backup.
         """
         return pulumi.get(self, "type")
 
@@ -28905,7 +30623,7 @@ class GetBackupsBackupResult(dict):
     @pulumi.getter
     def version(self) -> str:
         """
-        Version of the backup's source database
+        A filter to return only resources that match the given database version.
         """
         return pulumi.get(self, "version")
 
@@ -31009,9 +32727,11 @@ class GetCloudExadataInfrastructuresCloudExadataInfrastructureResult(dict):
                  cluster_placement_group_id: str,
                  compartment_id: str,
                  compute_count: int,
+                 compute_model: str,
                  cpu_count: int,
                  customer_contacts: Sequence['outputs.GetCloudExadataInfrastructuresCloudExadataInfrastructureCustomerContactResult'],
                  data_storage_size_in_tbs: float,
+                 database_server_type: str,
                  db_node_storage_size_in_gbs: int,
                  db_server_version: str,
                  defined_file_system_configurations: Sequence['outputs.GetCloudExadataInfrastructuresCloudExadataInfrastructureDefinedFileSystemConfigurationResult'],
@@ -31034,6 +32754,7 @@ class GetCloudExadataInfrastructuresCloudExadataInfrastructureResult(dict):
                  shape: str,
                  state: str,
                  storage_count: int,
+                 storage_server_type: str,
                  storage_server_version: str,
                  subscription_id: str,
                  system_tags: Mapping[str, str],
@@ -31047,9 +32768,11 @@ class GetCloudExadataInfrastructuresCloudExadataInfrastructureResult(dict):
         :param str cluster_placement_group_id: A filter to return only resources that match the given cluster placement group ID exactly.
         :param str compartment_id: The compartment [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
         :param int compute_count: The number of compute servers for the cloud Exadata infrastructure.
+        :param str compute_model: The compute model of the Exadata infrastructure.
         :param int cpu_count: The total number of CPU cores allocated.
         :param Sequence['GetCloudExadataInfrastructuresCloudExadataInfrastructureCustomerContactArgs'] customer_contacts: The list of customer email addresses that receive information from Oracle about the specified Oracle Cloud Infrastructure Database service resource. Oracle uses these email addresses to send notifications about planned and unplanned software maintenance updates, information about system hardware, and other information needed by administrators. Up to 10 email addresses can be added to the customer contacts for a cloud Exadata infrastructure instance.
         :param float data_storage_size_in_tbs: Size, in terabytes, of the DATA disk group.
+        :param str database_server_type: The database server type of the Exadata infrastructure.
         :param int db_node_storage_size_in_gbs: The local node storage allocated in GBs.
         :param str db_server_version: The software version of the database servers (dom0) in the cloud Exadata infrastructure. Example: 20.1.15
         :param Sequence['GetCloudExadataInfrastructuresCloudExadataInfrastructureDefinedFileSystemConfigurationArgs'] defined_file_system_configurations: Details of the file system configuration of the Exadata infrastructure.
@@ -31072,6 +32795,7 @@ class GetCloudExadataInfrastructuresCloudExadataInfrastructureResult(dict):
         :param str shape: The model name of the cloud Exadata infrastructure resource.
         :param str state: A filter to return only resources that match the given lifecycle state exactly.
         :param int storage_count: The number of storage servers for the cloud Exadata infrastructure.
+        :param str storage_server_type: The storage server type of the Exadata infrastructure.
         :param str storage_server_version: The software version of the storage servers (cells) in the cloud Exadata infrastructure. Example: 20.1.15
         :param str subscription_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the subscription with which resource needs to be associated with.
         :param Mapping[str, str] system_tags: System tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).
@@ -31085,9 +32809,11 @@ class GetCloudExadataInfrastructuresCloudExadataInfrastructureResult(dict):
         pulumi.set(__self__, "cluster_placement_group_id", cluster_placement_group_id)
         pulumi.set(__self__, "compartment_id", compartment_id)
         pulumi.set(__self__, "compute_count", compute_count)
+        pulumi.set(__self__, "compute_model", compute_model)
         pulumi.set(__self__, "cpu_count", cpu_count)
         pulumi.set(__self__, "customer_contacts", customer_contacts)
         pulumi.set(__self__, "data_storage_size_in_tbs", data_storage_size_in_tbs)
+        pulumi.set(__self__, "database_server_type", database_server_type)
         pulumi.set(__self__, "db_node_storage_size_in_gbs", db_node_storage_size_in_gbs)
         pulumi.set(__self__, "db_server_version", db_server_version)
         pulumi.set(__self__, "defined_file_system_configurations", defined_file_system_configurations)
@@ -31110,6 +32836,7 @@ class GetCloudExadataInfrastructuresCloudExadataInfrastructureResult(dict):
         pulumi.set(__self__, "shape", shape)
         pulumi.set(__self__, "state", state)
         pulumi.set(__self__, "storage_count", storage_count)
+        pulumi.set(__self__, "storage_server_type", storage_server_type)
         pulumi.set(__self__, "storage_server_version", storage_server_version)
         pulumi.set(__self__, "subscription_id", subscription_id)
         pulumi.set(__self__, "system_tags", system_tags)
@@ -31172,6 +32899,14 @@ class GetCloudExadataInfrastructuresCloudExadataInfrastructureResult(dict):
         """
         return pulumi.get(self, "compute_count")
 
+    @property
+    @pulumi.getter(name="computeModel")
+    def compute_model(self) -> str:
+        """
+        The compute model of the Exadata infrastructure.
+        """
+        return pulumi.get(self, "compute_model")
+
     @property
     @pulumi.getter(name="cpuCount")
     def cpu_count(self) -> int:
@@ -31196,6 +32931,14 @@ class GetCloudExadataInfrastructuresCloudExadataInfrastructureResult(dict):
         """
         return pulumi.get(self, "data_storage_size_in_tbs")
 
+    @property
+    @pulumi.getter(name="databaseServerType")
+    def database_server_type(self) -> str:
+        """
+        The database server type of the Exadata infrastructure.
+        """
+        return pulumi.get(self, "database_server_type")
+
     @property
     @pulumi.getter(name="dbNodeStorageSizeInGbs")
     def db_node_storage_size_in_gbs(self) -> int:
@@ -31372,6 +33115,14 @@ class GetCloudExadataInfrastructuresCloudExadataInfrastructureResult(dict):
         """
         return pulumi.get(self, "storage_count")
 
+    @property
+    @pulumi.getter(name="storageServerType")
+    def storage_server_type(self) -> str:
+        """
+        The storage server type of the Exadata infrastructure.
+        """
+        return pulumi.get(self, "storage_server_type")
+
     @property
     @pulumi.getter(name="storageServerVersion")
     def storage_server_version(self) -> str:
@@ -31996,6 +33747,7 @@ class GetCloudVmClustersCloudVmClusterResult(dict):
                  cloud_exadata_infrastructure_id: str,
                  cluster_name: str,
                  compartment_id: str,
+                 compute_model: str,
                  cpu_core_count: int,
                  create_async: bool,
                  data_collection_options: Sequence['outputs.GetCloudVmClustersCloudVmClusterDataCollectionOptionResult'],
@@ -32027,6 +33779,7 @@ class GetCloudVmClustersCloudVmClusterResult(dict):
                  scan_dns_name: str,
                  scan_dns_record_id: str,
                  scan_ip_ids: Sequence[str],
+                 scan_ipv6ids: Sequence[str],
                  scan_listener_port_tcp: int,
                  scan_listener_port_tcp_ssl: int,
                  security_attributes: Mapping[str, str],
@@ -32041,6 +33794,8 @@ class GetCloudVmClustersCloudVmClusterResult(dict):
                  time_created: str,
                  time_zone: str,
                  vip_ids: Sequence[str],
+                 vipv6ids: Sequence[str],
+                 vm_cluster_type: str,
                  zone_id: str):
         """
         :param str availability_domain: The name of the availability domain that the cloud Exadata infrastructure resource is located in.
@@ -32050,6 +33805,7 @@ class GetCloudVmClustersCloudVmClusterResult(dict):
         :param str cloud_exadata_infrastructure_id: If provided, filters the results for the specified cloud Exadata infrastructure.
         :param str cluster_name: The cluster name for cloud VM cluster. The cluster name must begin with an alphabetic character, and may contain hyphens (-). Underscores (_) are not permitted. The cluster name can be no longer than 11 characters and is not case sensitive.
         :param str compartment_id: The compartment [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
+        :param str compute_model: The compute model of the cloud VM cluster.
         :param int cpu_core_count: The number of CPU cores enabled on the cloud VM cluster.
         :param Sequence['GetCloudVmClustersCloudVmClusterDataCollectionOptionArgs'] data_collection_options: Indicates user preferences for the various diagnostic collection options for the VM cluster/Cloud VM cluster/VMBM DBCS.
         :param int data_storage_percentage: The percentage assigned to DATA storage (user data and database files). The remaining percentage is assigned to RECO storage (database redo logs, archive logs, and recovery manager backups). Accepted values are 35, 40, 60 and 80. The default is 80 percent assigned to DATA storage. See [Storage Configuration](https://docs.cloud.oracle.com/iaas/Content/Database/Concepts/exaoverview.htm#Exadata) in the Exadata documentation for details on the impact of the configuration settings on storage.
@@ -32078,7 +33834,8 @@ class GetCloudVmClustersCloudVmClusterResult(dict):
         :param float ocpu_count: The number of OCPU cores to enable on the cloud VM cluster. Only 1 decimal place is allowed for the fractional part.
         :param str scan_dns_name: The FQDN of the DNS record for the SCAN IP addresses that are associated with the cloud VM cluster.
         :param str scan_dns_record_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the DNS record for the SCAN IP addresses that are associated with the cloud VM cluster.
-        :param Sequence[str] scan_ip_ids: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Single Client Access Name (SCAN) IP addresses associated with the cloud VM cluster. SCAN IP addresses are typically used for load balancing and are not assigned to any interface. Oracle Clusterware directs the requests to the appropriate nodes in the cluster.
+        :param Sequence[str] scan_ip_ids: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Single Client Access Name (SCAN) IPv4 addresses associated with the cloud VM cluster. SCAN IPv4 addresses are typically used for load balancing and are not assigned to any interface. Oracle Clusterware directs the requests to the appropriate nodes in the cluster.
+        :param Sequence[str] scan_ipv6ids: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Single Client Access Name (SCAN) IPv6 addresses associated with the cloud VM cluster. SCAN IPv6 addresses are typically used for load balancing and are not assigned to any interface. Oracle Clusterware directs the requests to the appropriate nodes in the cluster.
         :param int scan_listener_port_tcp: The TCP Single Client Access Name (SCAN) port. The default port is 1521.
         :param int scan_listener_port_tcp_ssl: The TCPS Single Client Access Name (SCAN) port. The default port is 2484.
         :param Mapping[str, str] security_attributes: Security Attributes for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). Example: `{"Oracle-ZPR": {"MaxEgressCount": {"value": "42", "mode": "audit"}}}`
@@ -32092,7 +33849,9 @@ class GetCloudVmClustersCloudVmClusterResult(dict):
         :param str system_version: Operating system version of the image.
         :param str time_created: The date and time that the cloud VM cluster was created.
         :param str time_zone: The time zone of the cloud VM cluster. For details, see [Exadata Infrastructure Time Zones](https://docs.cloud.oracle.com/iaas/Content/Database/References/timezones.htm).
-        :param Sequence[str] vip_ids: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the virtual IP (VIP) addresses associated with the cloud VM cluster. The Cluster Ready Services (CRS) creates and maintains one VIP address for each node in the Exadata Cloud Service instance to enable failover. If one node fails, the VIP is reassigned to another active node in the cluster.
+        :param Sequence[str] vip_ids: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the virtual IP (VIP) IPv4 addresses associated with the cloud VM cluster. The Cluster Ready Services (CRS) creates and maintains one VIP IPv4 address for each node in the Exadata Cloud Service instance to enable failover. If one node fails, the VIP is reassigned to another active node in the cluster.
+        :param Sequence[str] vipv6ids: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the virtual IP (VIP) IPv6 addresses associated with the cloud VM cluster. The Cluster Ready Services (CRS) creates and maintains one VIP IPv6 address for each node in the Exadata Cloud Service instance to enable failover. If one node fails, the VIP is reassigned to another active node in the cluster.
+        :param str vm_cluster_type: A filter to return only cloud vmclusters that match the given cloud vmcluster type exactly.
         :param str zone_id: The OCID of the zone the cloud VM cluster is associated with.
         """
         pulumi.set(__self__, "availability_domain", availability_domain)
@@ -32102,6 +33861,7 @@ class GetCloudVmClustersCloudVmClusterResult(dict):
         pulumi.set(__self__, "cloud_exadata_infrastructure_id", cloud_exadata_infrastructure_id)
         pulumi.set(__self__, "cluster_name", cluster_name)
         pulumi.set(__self__, "compartment_id", compartment_id)
+        pulumi.set(__self__, "compute_model", compute_model)
         pulumi.set(__self__, "cpu_core_count", cpu_core_count)
         pulumi.set(__self__, "create_async", create_async)
         pulumi.set(__self__, "data_collection_options", data_collection_options)
@@ -32133,6 +33893,7 @@ class GetCloudVmClustersCloudVmClusterResult(dict):
         pulumi.set(__self__, "scan_dns_name", scan_dns_name)
         pulumi.set(__self__, "scan_dns_record_id", scan_dns_record_id)
         pulumi.set(__self__, "scan_ip_ids", scan_ip_ids)
+        pulumi.set(__self__, "scan_ipv6ids", scan_ipv6ids)
         pulumi.set(__self__, "scan_listener_port_tcp", scan_listener_port_tcp)
         pulumi.set(__self__, "scan_listener_port_tcp_ssl", scan_listener_port_tcp_ssl)
         pulumi.set(__self__, "security_attributes", security_attributes)
@@ -32147,6 +33908,8 @@ class GetCloudVmClustersCloudVmClusterResult(dict):
         pulumi.set(__self__, "time_created", time_created)
         pulumi.set(__self__, "time_zone", time_zone)
         pulumi.set(__self__, "vip_ids", vip_ids)
+        pulumi.set(__self__, "vipv6ids", vipv6ids)
+        pulumi.set(__self__, "vm_cluster_type", vm_cluster_type)
         pulumi.set(__self__, "zone_id", zone_id)
 
     @property
@@ -32205,6 +33968,14 @@ class GetCloudVmClustersCloudVmClusterResult(dict):
         """
         return pulumi.get(self, "compartment_id")
 
+    @property
+    @pulumi.getter(name="computeModel")
+    def compute_model(self) -> str:
+        """
+        The compute model of the cloud VM cluster.
+        """
+        return pulumi.get(self, "compute_model")
+
     @property
     @pulumi.getter(name="cpuCoreCount")
     def cpu_core_count(self) -> int:
@@ -32441,10 +34212,18 @@ class GetCloudVmClustersCloudVmClusterResult(dict):
     @pulumi.getter(name="scanIpIds")
     def scan_ip_ids(self) -> Sequence[str]:
         """
-        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Single Client Access Name (SCAN) IP addresses associated with the cloud VM cluster. SCAN IP addresses are typically used for load balancing and are not assigned to any interface. Oracle Clusterware directs the requests to the appropriate nodes in the cluster.
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Single Client Access Name (SCAN) IPv4 addresses associated with the cloud VM cluster. SCAN IPv4 addresses are typically used for load balancing and are not assigned to any interface. Oracle Clusterware directs the requests to the appropriate nodes in the cluster.
         """
         return pulumi.get(self, "scan_ip_ids")
 
+    @property
+    @pulumi.getter(name="scanIpv6ids")
+    def scan_ipv6ids(self) -> Sequence[str]:
+        """
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Single Client Access Name (SCAN) IPv6 addresses associated with the cloud VM cluster. SCAN IPv6 addresses are typically used for load balancing and are not assigned to any interface. Oracle Clusterware directs the requests to the appropriate nodes in the cluster.
+        """
+        return pulumi.get(self, "scan_ipv6ids")
+
     @property
     @pulumi.getter(name="scanListenerPortTcp")
     def scan_listener_port_tcp(self) -> int:
@@ -32553,10 +34332,26 @@ class GetCloudVmClustersCloudVmClusterResult(dict):
     @pulumi.getter(name="vipIds")
     def vip_ids(self) -> Sequence[str]:
         """
-        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the virtual IP (VIP) addresses associated with the cloud VM cluster. The Cluster Ready Services (CRS) creates and maintains one VIP address for each node in the Exadata Cloud Service instance to enable failover. If one node fails, the VIP is reassigned to another active node in the cluster.
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the virtual IP (VIP) IPv4 addresses associated with the cloud VM cluster. The Cluster Ready Services (CRS) creates and maintains one VIP IPv4 address for each node in the Exadata Cloud Service instance to enable failover. If one node fails, the VIP is reassigned to another active node in the cluster.
         """
         return pulumi.get(self, "vip_ids")
 
+    @property
+    @pulumi.getter
+    def vipv6ids(self) -> Sequence[str]:
+        """
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the virtual IP (VIP) IPv6 addresses associated with the cloud VM cluster. The Cluster Ready Services (CRS) creates and maintains one VIP IPv6 address for each node in the Exadata Cloud Service instance to enable failover. If one node fails, the VIP is reassigned to another active node in the cluster.
+        """
+        return pulumi.get(self, "vipv6ids")
+
+    @property
+    @pulumi.getter(name="vmClusterType")
+    def vm_cluster_type(self) -> str:
+        """
+        A filter to return only cloud vmclusters that match the given cloud vmcluster type exactly.
+        """
+        return pulumi.get(self, "vm_cluster_type")
+
     @property
     @pulumi.getter(name="zoneId")
     def zone_id(self) -> str:
@@ -32906,6 +34701,7 @@ class GetDataGuardAssociationsDataGuardAssociationResult(dict):
                  peer_sid_prefix: str,
                  peer_vm_cluster_id: str,
                  private_ip: str,
+                 private_ip_v6: str,
                  protection_mode: str,
                  role: str,
                  shape: str,
@@ -32970,6 +34766,7 @@ class GetDataGuardAssociationsDataGuardAssociationResult(dict):
         pulumi.set(__self__, "peer_sid_prefix", peer_sid_prefix)
         pulumi.set(__self__, "peer_vm_cluster_id", peer_vm_cluster_id)
         pulumi.set(__self__, "private_ip", private_ip)
+        pulumi.set(__self__, "private_ip_v6", private_ip_v6)
         pulumi.set(__self__, "protection_mode", protection_mode)
         pulumi.set(__self__, "role", role)
         pulumi.set(__self__, "shape", shape)
@@ -33198,6 +34995,11 @@ class GetDataGuardAssociationsDataGuardAssociationResult(dict):
     def private_ip(self) -> str:
         return pulumi.get(self, "private_ip")
 
+    @property
+    @pulumi.getter(name="privateIpV6")
+    def private_ip_v6(self) -> str:
+        return pulumi.get(self, "private_ip_v6")
+
     @property
     @pulumi.getter(name="protectionMode")
     def protection_mode(self) -> str:
@@ -39696,6 +41498,7 @@ class GetDbNodesDbNodeResult(dict):
     def __init__(__self__, *,
                  additional_details: str,
                  backup_ip_id: str,
+                 backup_ipv6id: str,
                  backup_vnic2id: str,
                  backup_vnic_id: str,
                  cpu_core_count: int,
@@ -39707,6 +41510,7 @@ class GetDbNodesDbNodeResult(dict):
                  fault_domain: str,
                  freeform_tags: Mapping[str, str],
                  host_ip_id: str,
+                 host_ipv6id: str,
                  hostname: str,
                  id: str,
                  lifecycle_details: str,
@@ -39722,7 +41526,8 @@ class GetDbNodesDbNodeResult(dict):
                  vnic_id: str):
         """
         :param str additional_details: Additional information about the planned maintenance.
-        :param str backup_ip_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the backup IP address associated with the database node. Use this OCID with either the [GetPrivateIp](https://docs.cloud.oracle.com/iaas/api/#/en/iaas/20160918/PrivateIp/GetPrivateIp) or the [GetPublicIpByPrivateIpId](https://docs.cloud.oracle.com/iaas/api/#/en/iaas/20160918/PublicIp/GetPublicIpByPrivateIpId) API to get the IP address needed to make a database connection.
+        :param str backup_ip_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the backup IPv4 address associated with the database node. Use this OCID with either the [GetPrivateIp](https://docs.cloud.oracle.com/iaas/api/#/en/iaas/20160918/PrivateIp/GetPrivateIp) or the [GetPublicIpByPrivateIpId](https://docs.cloud.oracle.com/iaas/api/#/en/iaas/20160918/PublicIp/GetPublicIpByPrivateIpId) API to get the IPv4 address needed to make a database connection.
+        :param str backup_ipv6id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the backup IPv6 address associated with the database node. Use this OCID with the [GetIpv6](https://docs.cloud.oracle.com/iaas/api/#/en/iaas/20160918/Ipv6/GetIpv6) API to get the IPv6 address needed to make a database connection.
         :param str backup_vnic2id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the second backup VNIC.
         :param str backup_vnic_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the backup VNIC.
         :param int cpu_core_count: The number of CPU cores enabled on the Db node.
@@ -39732,8 +41537,8 @@ class GetDbNodesDbNodeResult(dict):
         :param Mapping[str, str] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).
         :param str fault_domain: The name of the Fault Domain the instance is contained in.
         :param Mapping[str, str] freeform_tags: Free-form tags for this resource. Each tag is a simple key-value pair with no predefined name, type, or namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).  Example: `{"Department": "Finance"}`
-        :param str host_ip_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the host IP address associated with the database node. Use this OCID with either the  [GetPrivateIp](https://docs.cloud.oracle.com/iaas/api/#/en/iaas/20160918/PrivateIp/GetPrivateIp) or the [GetPublicIpByPrivateIpId](https://docs.cloud.oracle.com/iaas/api/#/en/iaas/20160918/PublicIp/GetPublicIpByPrivateIpId) API to get the IP address  needed to make a database connection.
-               **Note:** Applies only to Exadata Cloud Service.
+        :param str host_ip_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the host IPv4 address associated with the database node. Use this OCID with either the [GetPrivateIp](https://docs.cloud.oracle.com/iaas/api/#/en/iaas/20160918/PrivateIp/GetPrivateIp) or the [GetPublicIpByPrivateIpId](https://docs.cloud.oracle.com/iaas/api/#/en/iaas/20160918/PublicIp/GetPublicIpByPrivateIpId) API to get the IPv4 address needed to make a database connection.
+        :param str host_ipv6id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the host IPv6 address associated with the database node. Use this OCID with the [GetIpv6](https://docs.cloud.oracle.com/iaas/api/#/en/iaas/20160918/Ipv6/GetIpv6) API to get the IPv6 address needed to make a database connection.
         :param str hostname: The host name for the database node.
         :param str id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the database node.
         :param str lifecycle_details: Information about the current lifecycle state.
@@ -39750,6 +41555,7 @@ class GetDbNodesDbNodeResult(dict):
         """
         pulumi.set(__self__, "additional_details", additional_details)
         pulumi.set(__self__, "backup_ip_id", backup_ip_id)
+        pulumi.set(__self__, "backup_ipv6id", backup_ipv6id)
         pulumi.set(__self__, "backup_vnic2id", backup_vnic2id)
         pulumi.set(__self__, "backup_vnic_id", backup_vnic_id)
         pulumi.set(__self__, "cpu_core_count", cpu_core_count)
@@ -39761,6 +41567,7 @@ class GetDbNodesDbNodeResult(dict):
         pulumi.set(__self__, "fault_domain", fault_domain)
         pulumi.set(__self__, "freeform_tags", freeform_tags)
         pulumi.set(__self__, "host_ip_id", host_ip_id)
+        pulumi.set(__self__, "host_ipv6id", host_ipv6id)
         pulumi.set(__self__, "hostname", hostname)
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "lifecycle_details", lifecycle_details)
@@ -39787,10 +41594,18 @@ class GetDbNodesDbNodeResult(dict):
     @pulumi.getter(name="backupIpId")
     def backup_ip_id(self) -> str:
         """
-        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the backup IP address associated with the database node. Use this OCID with either the [GetPrivateIp](https://docs.cloud.oracle.com/iaas/api/#/en/iaas/20160918/PrivateIp/GetPrivateIp) or the [GetPublicIpByPrivateIpId](https://docs.cloud.oracle.com/iaas/api/#/en/iaas/20160918/PublicIp/GetPublicIpByPrivateIpId) API to get the IP address needed to make a database connection.
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the backup IPv4 address associated with the database node. Use this OCID with either the [GetPrivateIp](https://docs.cloud.oracle.com/iaas/api/#/en/iaas/20160918/PrivateIp/GetPrivateIp) or the [GetPublicIpByPrivateIpId](https://docs.cloud.oracle.com/iaas/api/#/en/iaas/20160918/PublicIp/GetPublicIpByPrivateIpId) API to get the IPv4 address needed to make a database connection.
         """
         return pulumi.get(self, "backup_ip_id")
 
+    @property
+    @pulumi.getter(name="backupIpv6id")
+    def backup_ipv6id(self) -> str:
+        """
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the backup IPv6 address associated with the database node. Use this OCID with the [GetIpv6](https://docs.cloud.oracle.com/iaas/api/#/en/iaas/20160918/Ipv6/GetIpv6) API to get the IPv6 address needed to make a database connection.
+        """
+        return pulumi.get(self, "backup_ipv6id")
+
     @property
     @pulumi.getter(name="backupVnic2id")
     def backup_vnic2id(self) -> str:
@@ -39872,11 +41687,18 @@ class GetDbNodesDbNodeResult(dict):
     @pulumi.getter(name="hostIpId")
     def host_ip_id(self) -> str:
         """
-        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the host IP address associated with the database node. Use this OCID with either the  [GetPrivateIp](https://docs.cloud.oracle.com/iaas/api/#/en/iaas/20160918/PrivateIp/GetPrivateIp) or the [GetPublicIpByPrivateIpId](https://docs.cloud.oracle.com/iaas/api/#/en/iaas/20160918/PublicIp/GetPublicIpByPrivateIpId) API to get the IP address  needed to make a database connection.
-        **Note:** Applies only to Exadata Cloud Service.
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the host IPv4 address associated with the database node. Use this OCID with either the [GetPrivateIp](https://docs.cloud.oracle.com/iaas/api/#/en/iaas/20160918/PrivateIp/GetPrivateIp) or the [GetPublicIpByPrivateIpId](https://docs.cloud.oracle.com/iaas/api/#/en/iaas/20160918/PublicIp/GetPublicIpByPrivateIpId) API to get the IPv4 address needed to make a database connection.
         """
         return pulumi.get(self, "host_ip_id")
 
+    @property
+    @pulumi.getter(name="hostIpv6id")
+    def host_ipv6id(self) -> str:
+        """
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the host IPv6 address associated with the database node. Use this OCID with the [GetIpv6](https://docs.cloud.oracle.com/iaas/api/#/en/iaas/20160918/Ipv6/GetIpv6) API to get the IPv6 address needed to make a database connection.
+        """
+        return pulumi.get(self, "host_ipv6id")
+
     @property
     @pulumi.getter
     def hostname(self) -> str:
@@ -40066,6 +41888,7 @@ class GetDbServersDbServerResult(dict):
                  autonomous_virtual_machine_ids: Sequence[str],
                  autonomous_vm_cluster_ids: Sequence[str],
                  compartment_id: str,
+                 compute_model: str,
                  cpu_core_count: int,
                  db_node_ids: Sequence[str],
                  db_node_storage_size_in_gbs: int,
@@ -40088,6 +41911,7 @@ class GetDbServersDbServerResult(dict):
         :param Sequence[str] autonomous_virtual_machine_ids: The list of [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Autonomous Virtual Machines associated with the Db server.
         :param Sequence[str] autonomous_vm_cluster_ids: The list of [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Autonomous VM Clusters associated with the Db server.
         :param str compartment_id: The compartment [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
+        :param str compute_model: The compute model of the Autonomous Database. This is required if using the `computeCount` parameter. If using `cpuCoreCount` then it is an error to specify `computeModel` to a non-null value. ECPU compute model is the recommended model and OCPU compute model is legacy.
         :param int cpu_core_count: The number of CPU cores enabled on the Db server.
         :param Sequence[str] db_node_ids: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Db nodes associated with the Db server.
         :param int db_node_storage_size_in_gbs: The allocated local node storage in GBs on the Db server.
@@ -40110,6 +41934,7 @@ class GetDbServersDbServerResult(dict):
         pulumi.set(__self__, "autonomous_virtual_machine_ids", autonomous_virtual_machine_ids)
         pulumi.set(__self__, "autonomous_vm_cluster_ids", autonomous_vm_cluster_ids)
         pulumi.set(__self__, "compartment_id", compartment_id)
+        pulumi.set(__self__, "compute_model", compute_model)
         pulumi.set(__self__, "cpu_core_count", cpu_core_count)
         pulumi.set(__self__, "db_node_ids", db_node_ids)
         pulumi.set(__self__, "db_node_storage_size_in_gbs", db_node_storage_size_in_gbs)
@@ -40153,6 +41978,14 @@ class GetDbServersDbServerResult(dict):
         """
         return pulumi.get(self, "compartment_id")
 
+    @property
+    @pulumi.getter(name="computeModel")
+    def compute_model(self) -> str:
+        """
+        The compute model of the Autonomous Database. This is required if using the `computeCount` parameter. If using `cpuCoreCount` then it is an error to specify `computeModel` to a non-null value. ECPU compute model is the recommended model and OCPU compute model is legacy.
+        """
+        return pulumi.get(self, "compute_model")
+
     @property
     @pulumi.getter(name="cpuCoreCount")
     def cpu_core_count(self) -> int:
@@ -40741,6 +42574,7 @@ class GetDbSystemPatchesPatchResult(dict):
 @pulumi.output_type
 class GetDbSystemShapesDbSystemShapeResult(dict):
     def __init__(__self__, *,
+                 are_server_types_supported: bool,
                  available_core_count: int,
                  available_core_count_per_node: int,
                  available_data_storage_in_tbs: int,
@@ -40749,7 +42583,9 @@ class GetDbSystemShapesDbSystemShapeResult(dict):
                  available_db_node_storage_in_gbs: int,
                  available_memory_in_gbs: int,
                  available_memory_per_node_in_gbs: int,
+                 compute_model: str,
                  core_count_increment: int,
+                 display_name: str,
                  max_storage_count: int,
                  maximum_node_count: int,
                  min_core_count_per_node: int,
@@ -40764,6 +42600,7 @@ class GetDbSystemShapesDbSystemShapeResult(dict):
                  shape_family: str,
                  shape_type: str):
         """
+        :param bool are_server_types_supported: If true, the shape supports configurable DB and Storage Server types.
         :param int available_core_count: The maximum number of CPU cores that can be enabled on the DB system for this shape.
         :param int available_core_count_per_node: The maximum number of CPU cores per database node that can be enabled for this shape. Only applicable to the flex Exadata shape, ExaCC Elastic shapes and VM Flex shapes.
         :param int available_data_storage_in_tbs: The maximum DATA storage that can be enabled for this shape.
@@ -40772,7 +42609,9 @@ class GetDbSystemShapesDbSystemShapeResult(dict):
         :param int available_db_node_storage_in_gbs: The maximum Db Node storage that can be enabled for this shape.
         :param int available_memory_in_gbs: The maximum memory that can be enabled for this shape.
         :param int available_memory_per_node_in_gbs: The maximum memory available per database node for this shape. Only applicable to ExaCC Elastic shapes.
+        :param str compute_model: The compute model of the Autonomous Database. This is required if using the `computeCount` parameter. If using `cpuCoreCount` then it is an error to specify `computeModel` to a non-null value. ECPU compute model is the recommended model and OCPU compute model is legacy.
         :param int core_count_increment: The discrete number by which the CPU core count for this shape can be increased or decreased.
+        :param str display_name: The display name of the shape used for the DB system.
         :param int max_storage_count: The maximum number of Exadata storage servers available for the Exadata infrastructure.
         :param int maximum_node_count: The maximum number of compute servers available for this shape.
         :param int min_core_count_per_node: The minimum number of CPU cores that can be enabled per node for this shape.
@@ -40787,6 +42626,7 @@ class GetDbSystemShapesDbSystemShapeResult(dict):
         :param str shape_family: The family of the shape used for the DB system.
         :param str shape_type: The shape type for the virtual machine DB system. Shape type is determined by CPU hardware. Valid values are `AMD` , `INTEL` or `INTEL_FLEX_X9`.
         """
+        pulumi.set(__self__, "are_server_types_supported", are_server_types_supported)
         pulumi.set(__self__, "available_core_count", available_core_count)
         pulumi.set(__self__, "available_core_count_per_node", available_core_count_per_node)
         pulumi.set(__self__, "available_data_storage_in_tbs", available_data_storage_in_tbs)
@@ -40795,7 +42635,9 @@ class GetDbSystemShapesDbSystemShapeResult(dict):
         pulumi.set(__self__, "available_db_node_storage_in_gbs", available_db_node_storage_in_gbs)
         pulumi.set(__self__, "available_memory_in_gbs", available_memory_in_gbs)
         pulumi.set(__self__, "available_memory_per_node_in_gbs", available_memory_per_node_in_gbs)
+        pulumi.set(__self__, "compute_model", compute_model)
         pulumi.set(__self__, "core_count_increment", core_count_increment)
+        pulumi.set(__self__, "display_name", display_name)
         pulumi.set(__self__, "max_storage_count", max_storage_count)
         pulumi.set(__self__, "maximum_node_count", maximum_node_count)
         pulumi.set(__self__, "min_core_count_per_node", min_core_count_per_node)
@@ -40810,6 +42652,14 @@ class GetDbSystemShapesDbSystemShapeResult(dict):
         pulumi.set(__self__, "shape_family", shape_family)
         pulumi.set(__self__, "shape_type", shape_type)
 
+    @property
+    @pulumi.getter(name="areServerTypesSupported")
+    def are_server_types_supported(self) -> bool:
+        """
+        If true, the shape supports configurable DB and Storage Server types.
+        """
+        return pulumi.get(self, "are_server_types_supported")
+
     @property
     @pulumi.getter(name="availableCoreCount")
     def available_core_count(self) -> int:
@@ -40874,6 +42724,14 @@ class GetDbSystemShapesDbSystemShapeResult(dict):
         """
         return pulumi.get(self, "available_memory_per_node_in_gbs")
 
+    @property
+    @pulumi.getter(name="computeModel")
+    def compute_model(self) -> str:
+        """
+        The compute model of the Autonomous Database. This is required if using the `computeCount` parameter. If using `cpuCoreCount` then it is an error to specify `computeModel` to a non-null value. ECPU compute model is the recommended model and OCPU compute model is legacy.
+        """
+        return pulumi.get(self, "compute_model")
+
     @property
     @pulumi.getter(name="coreCountIncrement")
     def core_count_increment(self) -> int:
@@ -40882,6 +42740,14 @@ class GetDbSystemShapesDbSystemShapeResult(dict):
         """
         return pulumi.get(self, "core_count_increment")
 
+    @property
+    @pulumi.getter(name="displayName")
+    def display_name(self) -> str:
+        """
+        The display name of the shape used for the DB system.
+        """
+        return pulumi.get(self, "display_name")
+
     @property
     @pulumi.getter(name="maxStorageCount")
     def max_storage_count(self) -> int:
@@ -41324,10 +43190,12 @@ class GetDbSystemsDbSystemResult(dict):
                  os_version: str,
                  point_in_time_data_disk_clone_timestamp: str,
                  private_ip: str,
+                 private_ip_v6: str,
                  reco_storage_size_in_gb: int,
                  scan_dns_name: str,
                  scan_dns_record_id: str,
                  scan_ip_ids: Sequence[str],
+                 scan_ipv6ids: Sequence[str],
                  security_attributes: Mapping[str, str],
                  shape: str,
                  source: str,
@@ -41341,6 +43209,7 @@ class GetDbSystemsDbSystemResult(dict):
                  time_zone: str,
                  version: str,
                  vip_ids: Sequence[str],
+                 vipv6ids: Sequence[str],
                  zone_id: str):
         """
         :param str availability_domain: A filter to return only resources that match the given availability domain exactly.
@@ -41352,7 +43221,7 @@ class GetDbSystemsDbSystemResult(dict):
         :param Sequence['GetDbSystemsDbSystemDataCollectionOptionArgs'] data_collection_options: Indicates user preferences for the various diagnostic collection options for the VM cluster/Cloud VM cluster/VMBM DBCS.
         :param int data_storage_percentage: The percentage assigned to DATA storage (user data and database files). The remaining percentage is assigned to RECO storage (database redo logs, archive logs, and recovery manager backups). Accepted values are 40 and 80. The default is 80 percent assigned to DATA storage. Not applicable for virtual machine DB systems. Required for BMDBs.
         :param int data_storage_size_in_gb: The data storage size, in gigabytes, that is currently available to the DB system. Applies only for virtual machine DB systems. Required for VMDBs.
-        :param str database_edition: The Oracle Database edition that applies to all the databases on the DB system.
+        :param str database_edition: The Oracle Database Edition that applies to all the databases on the DB system. Exadata DB systems and 2-node RAC DB systems require ENTERPRISE_EDITION_EXTREME_PERFORMANCE.
         :param Sequence['GetDbSystemsDbSystemDbSystemOptionArgs'] db_system_options: The DB system options.
         :param Mapping[str, str] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).
         :param str disk_redundancy: The type of redundancy configured for the DB system. NORMAL is 2-way redundancy. HIGH is 3-way redundancy.
@@ -41379,7 +43248,8 @@ class GetDbSystemsDbSystemResult(dict):
         :param int reco_storage_size_in_gb: The RECO/REDO storage size, in gigabytes, that is currently allocated to the DB system. Applies only for virtual machine DB systems.
         :param str scan_dns_name: The FQDN of the DNS record for the SCAN IP addresses that are associated with the DB system.
         :param str scan_dns_record_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the DNS record for the SCAN IP addresses that are associated with the DB system.
-        :param Sequence[str] scan_ip_ids: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Single Client Access Name (SCAN) IP addresses associated with the DB system. SCAN IP addresses are typically used for load balancing and are not assigned to any interface. Oracle Clusterware directs the requests to the appropriate nodes in the cluster.
+        :param Sequence[str] scan_ip_ids: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Single Client Access Name (SCAN) IPv4 addresses associated with the DB system. SCAN IPv4 addresses are typically used for load balancing and are not assigned to any interface. Oracle Clusterware directs the requests to the appropriate nodes in the cluster.
+        :param Sequence[str] scan_ipv6ids: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Single Client Access Name (SCAN) IPv6 addresses associated with the DB system. SCAN IPv6 addresses are typically used for load balancing and are not assigned to any interface. Oracle Clusterware directs the requests to the appropriate nodes in the cluster.
         :param Mapping[str, str] security_attributes: Security Attributes for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). Example: `{"Oracle-ZPR": {"MaxEgressCount": {"value": "42", "mode": "audit"}}}`
         :param str shape: The shape of the DB system. The shape determines resources to allocate to the DB system.
                * For virtual machine shapes, the number of CPU cores and memory
@@ -41393,7 +43263,8 @@ class GetDbSystemsDbSystemResult(dict):
         :param str time_created: The date and time the DB system was created.
         :param str time_zone: The time zone of the DB system. For details, see [DB System Time Zones](https://docs.cloud.oracle.com/iaas/Content/Database/References/timezones.htm).
         :param str version: The Oracle Database version of the DB system.
-        :param Sequence[str] vip_ids: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the virtual IP (VIP) addresses associated with the DB system. The Cluster Ready Services (CRS) creates and maintains one VIP address for each node in the DB system to enable failover. If one node fails, the VIP is reassigned to another active node in the cluster.
+        :param Sequence[str] vip_ids: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the virtual IPv4 (VIP) addresses associated with the DB system. The Cluster Ready Services (CRS) creates and maintains one VIPv4 address for each node in the DB system to enable failover. If one node fails, the VIPv4 is reassigned to another active node in the cluster.
+        :param Sequence[str] vipv6ids: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the virtual IPv6 (VIP) addresses associated with the DB system. The Cluster Ready Services (CRS) creates and maintains one VIP IpV6 address for each node in the DB system to enable failover. If one node fails, the VIP is reassigned to another active node in the cluster.
         :param str zone_id: The OCID of the zone the DB system is associated with.
         """
         pulumi.set(__self__, "availability_domain", availability_domain)
@@ -41433,10 +43304,12 @@ class GetDbSystemsDbSystemResult(dict):
         pulumi.set(__self__, "os_version", os_version)
         pulumi.set(__self__, "point_in_time_data_disk_clone_timestamp", point_in_time_data_disk_clone_timestamp)
         pulumi.set(__self__, "private_ip", private_ip)
+        pulumi.set(__self__, "private_ip_v6", private_ip_v6)
         pulumi.set(__self__, "reco_storage_size_in_gb", reco_storage_size_in_gb)
         pulumi.set(__self__, "scan_dns_name", scan_dns_name)
         pulumi.set(__self__, "scan_dns_record_id", scan_dns_record_id)
         pulumi.set(__self__, "scan_ip_ids", scan_ip_ids)
+        pulumi.set(__self__, "scan_ipv6ids", scan_ipv6ids)
         pulumi.set(__self__, "security_attributes", security_attributes)
         pulumi.set(__self__, "shape", shape)
         pulumi.set(__self__, "source", source)
@@ -41450,6 +43323,7 @@ class GetDbSystemsDbSystemResult(dict):
         pulumi.set(__self__, "time_zone", time_zone)
         pulumi.set(__self__, "version", version)
         pulumi.set(__self__, "vip_ids", vip_ids)
+        pulumi.set(__self__, "vipv6ids", vipv6ids)
         pulumi.set(__self__, "zone_id", zone_id)
 
     @property
@@ -41528,7 +43402,7 @@ class GetDbSystemsDbSystemResult(dict):
     @pulumi.getter(name="databaseEdition")
     def database_edition(self) -> str:
         """
-        The Oracle Database edition that applies to all the databases on the DB system.
+        The Oracle Database Edition that applies to all the databases on the DB system. Exadata DB systems and 2-node RAC DB systems require ENTERPRISE_EDITION_EXTREME_PERFORMANCE.
         """
         return pulumi.get(self, "database_edition")
 
@@ -41734,6 +43608,11 @@ class GetDbSystemsDbSystemResult(dict):
     def private_ip(self) -> str:
         return pulumi.get(self, "private_ip")
 
+    @property
+    @pulumi.getter(name="privateIpV6")
+    def private_ip_v6(self) -> str:
+        return pulumi.get(self, "private_ip_v6")
+
     @property
     @pulumi.getter(name="recoStorageSizeInGb")
     def reco_storage_size_in_gb(self) -> int:
@@ -41762,10 +43641,18 @@ class GetDbSystemsDbSystemResult(dict):
     @pulumi.getter(name="scanIpIds")
     def scan_ip_ids(self) -> Sequence[str]:
         """
-        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Single Client Access Name (SCAN) IP addresses associated with the DB system. SCAN IP addresses are typically used for load balancing and are not assigned to any interface. Oracle Clusterware directs the requests to the appropriate nodes in the cluster.
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Single Client Access Name (SCAN) IPv4 addresses associated with the DB system. SCAN IPv4 addresses are typically used for load balancing and are not assigned to any interface. Oracle Clusterware directs the requests to the appropriate nodes in the cluster.
         """
         return pulumi.get(self, "scan_ip_ids")
 
+    @property
+    @pulumi.getter(name="scanIpv6ids")
+    def scan_ipv6ids(self) -> Sequence[str]:
+        """
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Single Client Access Name (SCAN) IPv6 addresses associated with the DB system. SCAN IPv6 addresses are typically used for load balancing and are not assigned to any interface. Oracle Clusterware directs the requests to the appropriate nodes in the cluster.
+        """
+        return pulumi.get(self, "scan_ipv6ids")
+
     @property
     @pulumi.getter(name="securityAttributes")
     def security_attributes(self) -> Mapping[str, str]:
@@ -41865,10 +43752,18 @@ class GetDbSystemsDbSystemResult(dict):
     @pulumi.getter(name="vipIds")
     def vip_ids(self) -> Sequence[str]:
         """
-        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the virtual IP (VIP) addresses associated with the DB system. The Cluster Ready Services (CRS) creates and maintains one VIP address for each node in the DB system to enable failover. If one node fails, the VIP is reassigned to another active node in the cluster.
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the virtual IPv4 (VIP) addresses associated with the DB system. The Cluster Ready Services (CRS) creates and maintains one VIPv4 address for each node in the DB system to enable failover. If one node fails, the VIPv4 is reassigned to another active node in the cluster.
         """
         return pulumi.get(self, "vip_ids")
 
+    @property
+    @pulumi.getter
+    def vipv6ids(self) -> Sequence[str]:
+        """
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the virtual IPv6 (VIP) addresses associated with the DB system. The Cluster Ready Services (CRS) creates and maintains one VIP IpV6 address for each node in the DB system to enable failover. If one node fails, the VIP is reassigned to another active node in the cluster.
+        """
+        return pulumi.get(self, "vipv6ids")
+
     @property
     @pulumi.getter(name="zoneId")
     def zone_id(self) -> str:
@@ -43203,6 +45098,35 @@ class GetExadataInfrastructureDefinedFileSystemConfigurationResult(dict):
         return pulumi.get(self, "mount_point")
 
 
+@pulumi.output_type
+class GetExadataInfrastructureExascaleConfigResult(dict):
+    def __init__(__self__, *,
+                 available_storage_in_gbs: int,
+                 total_storage_in_gbs: int):
+        """
+        :param int available_storage_in_gbs: Available storage size for Exascale in GBs.
+        :param int total_storage_in_gbs: Storage size needed for Exascale in GBs.
+        """
+        pulumi.set(__self__, "available_storage_in_gbs", available_storage_in_gbs)
+        pulumi.set(__self__, "total_storage_in_gbs", total_storage_in_gbs)
+
+    @property
+    @pulumi.getter(name="availableStorageInGbs")
+    def available_storage_in_gbs(self) -> int:
+        """
+        Available storage size for Exascale in GBs.
+        """
+        return pulumi.get(self, "available_storage_in_gbs")
+
+    @property
+    @pulumi.getter(name="totalStorageInGbs")
+    def total_storage_in_gbs(self) -> int:
+        """
+        Storage size needed for Exascale in GBs.
+        """
+        return pulumi.get(self, "total_storage_in_gbs")
+
+
 @pulumi.output_type
 class GetExadataInfrastructureMaintenanceWindowResult(dict):
     def __init__(__self__, *,
@@ -43448,18 +45372,21 @@ class GetExadataInfrastructuresExadataInfrastructureResult(dict):
                  cloud_control_plane_server2: str,
                  compartment_id: str,
                  compute_count: int,
+                 compute_model: str,
                  contacts: Sequence['outputs.GetExadataInfrastructuresExadataInfrastructureContactResult'],
                  corporate_proxy: str,
                  cpus_enabled: int,
                  create_async: bool,
                  csi_number: str,
                  data_storage_size_in_tbs: float,
+                 database_server_type: str,
                  db_node_storage_size_in_gbs: int,
                  db_server_version: str,
                  defined_file_system_configurations: Sequence['outputs.GetExadataInfrastructuresExadataInfrastructureDefinedFileSystemConfigurationResult'],
                  defined_tags: Mapping[str, str],
                  display_name: str,
                  dns_servers: Sequence[str],
+                 exascale_configs: Sequence['outputs.GetExadataInfrastructuresExadataInfrastructureExascaleConfigResult'],
                  freeform_tags: Mapping[str, str],
                  gateway: str,
                  id: str,
@@ -43484,6 +45411,7 @@ class GetExadataInfrastructuresExadataInfrastructureResult(dict):
                  shape: str,
                  state: str,
                  storage_count: int,
+                 storage_server_type: str,
                  storage_server_version: str,
                  time_created: str,
                  time_zone: str):
@@ -43498,17 +45426,20 @@ class GetExadataInfrastructuresExadataInfrastructureResult(dict):
         :param str cloud_control_plane_server2: The IP address for the second control plane server.
         :param str compartment_id: The compartment [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
         :param int compute_count: The number of compute servers for the Exadata infrastructure.
+        :param str compute_model: The compute model of the Autonomous Database. This is required if using the `computeCount` parameter. If using `cpuCoreCount` then it is an error to specify `computeModel` to a non-null value. ECPU compute model is the recommended model and OCPU compute model is legacy.
         :param Sequence['GetExadataInfrastructuresExadataInfrastructureContactArgs'] contacts: The list of contacts for the Exadata infrastructure.
         :param str corporate_proxy: The corporate network proxy for access to the control plane network.
         :param int cpus_enabled: The number of enabled CPU cores.
         :param str csi_number: The CSI Number of the Exadata infrastructure.
         :param float data_storage_size_in_tbs: Size, in terabytes, of the DATA disk group.
+        :param str database_server_type: The database server type of the Exadata infrastructure.
         :param int db_node_storage_size_in_gbs: The local node storage allocated in GBs.
         :param str db_server_version: The software version of the database servers (dom0) in the Exadata infrastructure.
         :param Sequence['GetExadataInfrastructuresExadataInfrastructureDefinedFileSystemConfigurationArgs'] defined_file_system_configurations: Details of the file system configuration of the Exadata infrastructure.
         :param Mapping[str, str] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).
         :param str display_name: A filter to return only resources that match the entire display name given. The match is not case sensitive.
         :param Sequence[str] dns_servers: The list of DNS server IP addresses. Maximum of 3 allowed.
+        :param Sequence['GetExadataInfrastructuresExadataInfrastructureExascaleConfigArgs'] exascale_configs: The exascale config response details for the Exadata Cloud@Customer infrastructure or cloud Exadata infrastructure . Applies to both Exadata Cloud@Customer instances and Exadata Cloud Service instances.
         :param Mapping[str, str] freeform_tags: Free-form tags for this resource. Each tag is a simple key-value pair with no predefined name, type, or namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).  Example: `{"Department": "Finance"}`
         :param str gateway: The gateway for the control plane network.
         :param str id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Exadata infrastructure.
@@ -43533,6 +45464,7 @@ class GetExadataInfrastructuresExadataInfrastructureResult(dict):
         :param str shape: The shape of the Exadata infrastructure. The shape determines the amount of CPU, storage, and memory resources allocated to the instance.
         :param str state: A filter to return only resources that match the given lifecycle state exactly.
         :param int storage_count: The number of Exadata storage servers for the Exadata infrastructure.
+        :param str storage_server_type: The storage server type of the Exadata infrastructure.
         :param str storage_server_version: The software version of the storage servers (cells) in the Exadata infrastructure.
         :param str time_created: The date and time the Exadata infrastructure was created.
         :param str time_zone: The time zone of the Exadata infrastructure. For details, see [Exadata Infrastructure Time Zones](https://docs.cloud.oracle.com/iaas/Content/Database/References/timezones.htm).
@@ -43548,18 +45480,21 @@ class GetExadataInfrastructuresExadataInfrastructureResult(dict):
         pulumi.set(__self__, "cloud_control_plane_server2", cloud_control_plane_server2)
         pulumi.set(__self__, "compartment_id", compartment_id)
         pulumi.set(__self__, "compute_count", compute_count)
+        pulumi.set(__self__, "compute_model", compute_model)
         pulumi.set(__self__, "contacts", contacts)
         pulumi.set(__self__, "corporate_proxy", corporate_proxy)
         pulumi.set(__self__, "cpus_enabled", cpus_enabled)
         pulumi.set(__self__, "create_async", create_async)
         pulumi.set(__self__, "csi_number", csi_number)
         pulumi.set(__self__, "data_storage_size_in_tbs", data_storage_size_in_tbs)
+        pulumi.set(__self__, "database_server_type", database_server_type)
         pulumi.set(__self__, "db_node_storage_size_in_gbs", db_node_storage_size_in_gbs)
         pulumi.set(__self__, "db_server_version", db_server_version)
         pulumi.set(__self__, "defined_file_system_configurations", defined_file_system_configurations)
         pulumi.set(__self__, "defined_tags", defined_tags)
         pulumi.set(__self__, "display_name", display_name)
         pulumi.set(__self__, "dns_servers", dns_servers)
+        pulumi.set(__self__, "exascale_configs", exascale_configs)
         pulumi.set(__self__, "freeform_tags", freeform_tags)
         pulumi.set(__self__, "gateway", gateway)
         pulumi.set(__self__, "id", id)
@@ -43584,6 +45519,7 @@ class GetExadataInfrastructuresExadataInfrastructureResult(dict):
         pulumi.set(__self__, "shape", shape)
         pulumi.set(__self__, "state", state)
         pulumi.set(__self__, "storage_count", storage_count)
+        pulumi.set(__self__, "storage_server_type", storage_server_type)
         pulumi.set(__self__, "storage_server_version", storage_server_version)
         pulumi.set(__self__, "time_created", time_created)
         pulumi.set(__self__, "time_zone", time_zone)
@@ -43673,6 +45609,14 @@ class GetExadataInfrastructuresExadataInfrastructureResult(dict):
         """
         return pulumi.get(self, "compute_count")
 
+    @property
+    @pulumi.getter(name="computeModel")
+    def compute_model(self) -> str:
+        """
+        The compute model of the Autonomous Database. This is required if using the `computeCount` parameter. If using `cpuCoreCount` then it is an error to specify `computeModel` to a non-null value. ECPU compute model is the recommended model and OCPU compute model is legacy.
+        """
+        return pulumi.get(self, "compute_model")
+
     @property
     @pulumi.getter
     def contacts(self) -> Sequence['outputs.GetExadataInfrastructuresExadataInfrastructureContactResult']:
@@ -43718,6 +45662,14 @@ class GetExadataInfrastructuresExadataInfrastructureResult(dict):
         """
         return pulumi.get(self, "data_storage_size_in_tbs")
 
+    @property
+    @pulumi.getter(name="databaseServerType")
+    def database_server_type(self) -> str:
+        """
+        The database server type of the Exadata infrastructure.
+        """
+        return pulumi.get(self, "database_server_type")
+
     @property
     @pulumi.getter(name="dbNodeStorageSizeInGbs")
     def db_node_storage_size_in_gbs(self) -> int:
@@ -43766,6 +45718,14 @@ class GetExadataInfrastructuresExadataInfrastructureResult(dict):
         """
         return pulumi.get(self, "dns_servers")
 
+    @property
+    @pulumi.getter(name="exascaleConfigs")
+    def exascale_configs(self) -> Sequence['outputs.GetExadataInfrastructuresExadataInfrastructureExascaleConfigResult']:
+        """
+        The exascale config response details for the Exadata Cloud@Customer infrastructure or cloud Exadata infrastructure . Applies to both Exadata Cloud@Customer instances and Exadata Cloud Service instances.
+        """
+        return pulumi.get(self, "exascale_configs")
+
     @property
     @pulumi.getter(name="freeformTags")
     def freeform_tags(self) -> Mapping[str, str]:
@@ -43958,6 +45918,14 @@ class GetExadataInfrastructuresExadataInfrastructureResult(dict):
         """
         return pulumi.get(self, "storage_count")
 
+    @property
+    @pulumi.getter(name="storageServerType")
+    def storage_server_type(self) -> str:
+        """
+        The storage server type of the Exadata infrastructure.
+        """
+        return pulumi.get(self, "storage_server_type")
+
     @property
     @pulumi.getter(name="storageServerVersion")
     def storage_server_version(self) -> str:
@@ -44096,6 +46064,35 @@ class GetExadataInfrastructuresExadataInfrastructureDefinedFileSystemConfigurati
         return pulumi.get(self, "mount_point")
 
 
+@pulumi.output_type
+class GetExadataInfrastructuresExadataInfrastructureExascaleConfigResult(dict):
+    def __init__(__self__, *,
+                 available_storage_in_gbs: int,
+                 total_storage_in_gbs: int):
+        """
+        :param int available_storage_in_gbs: Available storage size for Exascale in GBs.
+        :param int total_storage_in_gbs: Storage size needed for Exascale in GBs.
+        """
+        pulumi.set(__self__, "available_storage_in_gbs", available_storage_in_gbs)
+        pulumi.set(__self__, "total_storage_in_gbs", total_storage_in_gbs)
+
+    @property
+    @pulumi.getter(name="availableStorageInGbs")
+    def available_storage_in_gbs(self) -> int:
+        """
+        Available storage size for Exascale in GBs.
+        """
+        return pulumi.get(self, "available_storage_in_gbs")
+
+    @property
+    @pulumi.getter(name="totalStorageInGbs")
+    def total_storage_in_gbs(self) -> int:
+        """
+        Storage size needed for Exascale in GBs.
+        """
+        return pulumi.get(self, "total_storage_in_gbs")
+
+
 @pulumi.output_type
 class GetExadataInfrastructuresExadataInfrastructureMaintenanceWindowResult(dict):
     def __init__(__self__, *,
@@ -44895,6 +46892,7 @@ class GetExadbVmClustersExadbVmClusterResult(dict):
                  backup_network_nsg_ids: Sequence[str],
                  backup_subnet_id: str,
                  cluster_name: str,
+                 cluster_placement_group_id: str,
                  compartment_id: str,
                  data_collection_options: Sequence['outputs.GetExadbVmClustersExadbVmClusterDataCollectionOptionResult'],
                  defined_tags: Mapping[str, str],
@@ -44926,6 +46924,7 @@ class GetExadbVmClustersExadbVmClusterResult(dict):
                  ssh_public_keys: Sequence[str],
                  state: str,
                  subnet_id: str,
+                 subscription_id: str,
                  system_tags: Mapping[str, str],
                  system_version: str,
                  time_created: str,
@@ -44937,6 +46936,7 @@ class GetExadbVmClustersExadbVmClusterResult(dict):
         :param Sequence[str] backup_network_nsg_ids: A list of the [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network security groups (NSGs) that the backup network of this DB system belongs to. Setting this to an empty array after the list is created removes the resource from all NSGs. For more information about NSGs, see [Security Rules](https://docs.cloud.oracle.com/iaas/Content/Network/Concepts/securityrules.htm). Applicable only to Exadata systems.
         :param str backup_subnet_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the backup network subnet associated with the Exadata VM cluster on Exascale Infrastructure.
         :param str cluster_name: The cluster name for Exadata VM cluster on Exascale Infrastructure. The cluster name must begin with an alphabetic character, and may contain hyphens (-). Underscores (_) are not permitted. The cluster name can be no longer than 11 characters and is not case sensitive.
+        :param str cluster_placement_group_id: A filter to return only resources that match the given cluster placement group ID exactly.
         :param str compartment_id: The compartment [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
         :param Sequence['GetExadbVmClustersExadbVmClusterDataCollectionOptionArgs'] data_collection_options: Indicates user preferences for the various diagnostic collection options for the VM cluster/Cloud VM cluster/VMBM DBCS.
         :param Mapping[str, str] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).
@@ -44969,6 +46969,7 @@ class GetExadbVmClustersExadbVmClusterResult(dict):
         :param Sequence[str] ssh_public_keys: The public key portion of one or more key pairs used for SSH access to the Exadata VM cluster on Exascale Infrastructure.
         :param str state: A filter to return only Exadata VM clusters on Exascale Infrastructure that match the given lifecycle state exactly.
         :param str subnet_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the subnet associated with the Exadata VM cluster on Exascale Infrastructure.
+        :param str subscription_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the subscription with which resource needs to be associated with.
         :param Mapping[str, str] system_tags: System tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).
         :param str system_version: Operating system version of the image.
         :param str time_created: The date and time that the Exadata VM cluster on Exascale Infrastructure was created.
@@ -44980,6 +46981,7 @@ class GetExadbVmClustersExadbVmClusterResult(dict):
         pulumi.set(__self__, "backup_network_nsg_ids", backup_network_nsg_ids)
         pulumi.set(__self__, "backup_subnet_id", backup_subnet_id)
         pulumi.set(__self__, "cluster_name", cluster_name)
+        pulumi.set(__self__, "cluster_placement_group_id", cluster_placement_group_id)
         pulumi.set(__self__, "compartment_id", compartment_id)
         pulumi.set(__self__, "data_collection_options", data_collection_options)
         pulumi.set(__self__, "defined_tags", defined_tags)
@@ -45011,6 +47013,7 @@ class GetExadbVmClustersExadbVmClusterResult(dict):
         pulumi.set(__self__, "ssh_public_keys", ssh_public_keys)
         pulumi.set(__self__, "state", state)
         pulumi.set(__self__, "subnet_id", subnet_id)
+        pulumi.set(__self__, "subscription_id", subscription_id)
         pulumi.set(__self__, "system_tags", system_tags)
         pulumi.set(__self__, "system_version", system_version)
         pulumi.set(__self__, "time_created", time_created)
@@ -45050,6 +47053,14 @@ class GetExadbVmClustersExadbVmClusterResult(dict):
         """
         return pulumi.get(self, "cluster_name")
 
+    @property
+    @pulumi.getter(name="clusterPlacementGroupId")
+    def cluster_placement_group_id(self) -> str:
+        """
+        A filter to return only resources that match the given cluster placement group ID exactly.
+        """
+        return pulumi.get(self, "cluster_placement_group_id")
+
     @property
     @pulumi.getter(name="compartmentId")
     def compartment_id(self) -> str:
@@ -45299,6 +47310,14 @@ class GetExadbVmClustersExadbVmClusterResult(dict):
         """
         return pulumi.get(self, "subnet_id")
 
+    @property
+    @pulumi.getter(name="subscriptionId")
+    def subscription_id(self) -> str:
+        """
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the subscription with which resource needs to be associated with.
+        """
+        return pulumi.get(self, "subscription_id")
+
     @property
     @pulumi.getter(name="systemTags")
     def system_tags(self) -> Mapping[str, str]:
@@ -45652,15 +47671,18 @@ class GetExascaleDbStorageVaultsExascaleDbStorageVaultResult(dict):
     def __init__(__self__, *,
                  additional_flash_cache_in_percent: int,
                  availability_domain: str,
+                 cluster_placement_group_id: str,
                  compartment_id: str,
                  defined_tags: Mapping[str, str],
                  description: str,
                  display_name: str,
+                 exadata_infrastructure_id: str,
                  freeform_tags: Mapping[str, str],
                  high_capacity_database_storages: Sequence['outputs.GetExascaleDbStorageVaultsExascaleDbStorageVaultHighCapacityDatabaseStorageResult'],
                  id: str,
                  lifecycle_details: str,
                  state: str,
+                 subscription_id: str,
                  system_tags: Mapping[str, str],
                  time_created: str,
                  time_zone: str,
@@ -45669,15 +47691,18 @@ class GetExascaleDbStorageVaultsExascaleDbStorageVaultResult(dict):
         """
         :param int additional_flash_cache_in_percent: The size of additional Flash Cache in percentage of High Capacity database storage.
         :param str availability_domain: The name of the availability domain in which the Exadata Database Storage Vault is located.
+        :param str cluster_placement_group_id: A filter to return only resources that match the given cluster placement group ID exactly.
         :param str compartment_id: The compartment [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
         :param Mapping[str, str] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).
         :param str description: Exadata Database Storage Vault description.
         :param str display_name: A filter to return only resources that match the entire display name given. The match is not case sensitive.
+        :param str exadata_infrastructure_id: A filter to return only list of Vaults that are linked to the exadata infrastructure Id.
         :param Mapping[str, str] freeform_tags: Free-form tags for this resource. Each tag is a simple key-value pair with no predefined name, type, or namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).  Example: `{"Department": "Finance"}`
         :param Sequence['GetExascaleDbStorageVaultsExascaleDbStorageVaultHighCapacityDatabaseStorageArgs'] high_capacity_database_storages: Exadata Database Storage Details
         :param str id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Exadata Database Storage Vault.
         :param str lifecycle_details: Additional information about the current lifecycle state.
         :param str state: A filter to return only Exadata Database Storage Vaults that match the given lifecycle state exactly.
+        :param str subscription_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the subscription with which resource needs to be associated with.
         :param Mapping[str, str] system_tags: System tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).
         :param str time_created: The date and time that the Exadata Database Storage Vault was created.
         :param str time_zone: The time zone that you want to use for the Exadata Database Storage Vault. For details, see [Time Zones](https://docs.cloud.oracle.com/iaas/Content/Database/References/timezones.htm).
@@ -45686,15 +47711,18 @@ class GetExascaleDbStorageVaultsExascaleDbStorageVaultResult(dict):
         """
         pulumi.set(__self__, "additional_flash_cache_in_percent", additional_flash_cache_in_percent)
         pulumi.set(__self__, "availability_domain", availability_domain)
+        pulumi.set(__self__, "cluster_placement_group_id", cluster_placement_group_id)
         pulumi.set(__self__, "compartment_id", compartment_id)
         pulumi.set(__self__, "defined_tags", defined_tags)
         pulumi.set(__self__, "description", description)
         pulumi.set(__self__, "display_name", display_name)
+        pulumi.set(__self__, "exadata_infrastructure_id", exadata_infrastructure_id)
         pulumi.set(__self__, "freeform_tags", freeform_tags)
         pulumi.set(__self__, "high_capacity_database_storages", high_capacity_database_storages)
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "lifecycle_details", lifecycle_details)
         pulumi.set(__self__, "state", state)
+        pulumi.set(__self__, "subscription_id", subscription_id)
         pulumi.set(__self__, "system_tags", system_tags)
         pulumi.set(__self__, "time_created", time_created)
         pulumi.set(__self__, "time_zone", time_zone)
@@ -45717,6 +47745,14 @@ class GetExascaleDbStorageVaultsExascaleDbStorageVaultResult(dict):
         """
         return pulumi.get(self, "availability_domain")
 
+    @property
+    @pulumi.getter(name="clusterPlacementGroupId")
+    def cluster_placement_group_id(self) -> str:
+        """
+        A filter to return only resources that match the given cluster placement group ID exactly.
+        """
+        return pulumi.get(self, "cluster_placement_group_id")
+
     @property
     @pulumi.getter(name="compartmentId")
     def compartment_id(self) -> str:
@@ -45749,6 +47785,14 @@ class GetExascaleDbStorageVaultsExascaleDbStorageVaultResult(dict):
         """
         return pulumi.get(self, "display_name")
 
+    @property
+    @pulumi.getter(name="exadataInfrastructureId")
+    def exadata_infrastructure_id(self) -> str:
+        """
+        A filter to return only list of Vaults that are linked to the exadata infrastructure Id.
+        """
+        return pulumi.get(self, "exadata_infrastructure_id")
+
     @property
     @pulumi.getter(name="freeformTags")
     def freeform_tags(self) -> Mapping[str, str]:
@@ -45789,6 +47833,14 @@ class GetExascaleDbStorageVaultsExascaleDbStorageVaultResult(dict):
         """
         return pulumi.get(self, "state")
 
+    @property
+    @pulumi.getter(name="subscriptionId")
+    def subscription_id(self) -> str:
+        """
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the subscription with which resource needs to be associated with.
+        """
+        return pulumi.get(self, "subscription_id")
+
     @property
     @pulumi.getter(name="systemTags")
     def system_tags(self) -> Mapping[str, str]:
@@ -46619,7 +48671,7 @@ class GetExternalContainerDatabasesExternalContainerDatabaseResult(dict):
         :param str character_set: The character set of the external database.
         :param str compartment_id: The compartment [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
         :param str database_configuration: The Oracle Database configuration
-        :param str database_edition: The Oracle Database edition.
+        :param str database_edition: The Oracle Database Edition that applies to all the databases on the DB system. Exadata DB systems and 2-node RAC DB systems require ENTERPRISE_EDITION_EXTREME_PERFORMANCE.
         :param Sequence['GetExternalContainerDatabasesExternalContainerDatabaseDatabaseManagementConfigArgs'] database_management_configs: The configuration of the Database Management service.
         :param str database_version: The Oracle Database version.
         :param str db_id: The Oracle Database ID, which identifies an Oracle Database located outside of Oracle Cloud.
@@ -46684,7 +48736,7 @@ class GetExternalContainerDatabasesExternalContainerDatabaseResult(dict):
     @pulumi.getter(name="databaseEdition")
     def database_edition(self) -> str:
         """
-        The Oracle Database edition.
+        The Oracle Database Edition that applies to all the databases on the DB system. Exadata DB systems and 2-node RAC DB systems require ENTERPRISE_EDITION_EXTREME_PERFORMANCE.
         """
         return pulumi.get(self, "database_edition")
 
@@ -47477,7 +49529,7 @@ class GetExternalNonContainerDatabasesExternalNonContainerDatabaseResult(dict):
         :param str character_set: The character set of the external database.
         :param str compartment_id: The compartment [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
         :param str database_configuration: The Oracle Database configuration
-        :param str database_edition: The Oracle Database edition.
+        :param str database_edition: The Oracle Database Edition that applies to all the databases on the DB system. Exadata DB systems and 2-node RAC DB systems require ENTERPRISE_EDITION_EXTREME_PERFORMANCE.
         :param Sequence['GetExternalNonContainerDatabasesExternalNonContainerDatabaseDatabaseManagementConfigArgs'] database_management_configs: The configuration of the Database Management service.
         :param str database_version: The Oracle Database version.
         :param str db_id: The Oracle Database ID, which identifies an Oracle Database located outside of Oracle Cloud.
@@ -47544,7 +49596,7 @@ class GetExternalNonContainerDatabasesExternalNonContainerDatabaseResult(dict):
     @pulumi.getter(name="databaseEdition")
     def database_edition(self) -> str:
         """
-        The Oracle Database edition.
+        The Oracle Database Edition that applies to all the databases on the DB system. Exadata DB systems and 2-node RAC DB systems require ENTERPRISE_EDITION_EXTREME_PERFORMANCE.
         """
         return pulumi.get(self, "database_edition")
 
@@ -47929,7 +49981,7 @@ class GetExternalPluggableDatabasesExternalPluggableDatabaseResult(dict):
         :param str character_set: The character set of the external database.
         :param str compartment_id: The compartment [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
         :param str database_configuration: The Oracle Database configuration
-        :param str database_edition: The Oracle Database edition.
+        :param str database_edition: The Oracle Database Edition that applies to all the databases on the DB system. Exadata DB systems and 2-node RAC DB systems require ENTERPRISE_EDITION_EXTREME_PERFORMANCE.
         :param Sequence['GetExternalPluggableDatabasesExternalPluggableDatabaseDatabaseManagementConfigArgs'] database_management_configs: The configuration of the Database Management service.
         :param str database_version: The Oracle Database version.
         :param str db_id: The Oracle Database ID, which identifies an Oracle Database located outside of Oracle Cloud.
@@ -48000,7 +50052,7 @@ class GetExternalPluggableDatabasesExternalPluggableDatabaseResult(dict):
     @pulumi.getter(name="databaseEdition")
     def database_edition(self) -> str:
         """
-        The Oracle Database edition.
+        The Oracle Database Edition that applies to all the databases on the DB system. Exadata DB systems and 2-node RAC DB systems require ENTERPRISE_EDITION_EXTREME_PERFORMANCE.
         """
         return pulumi.get(self, "database_edition")
 
@@ -48324,18 +50376,39 @@ class GetFlexComponentsFlexComponentCollectionItemResult(dict):
     def __init__(__self__, *,
                  available_core_count: int,
                  available_db_storage_in_gbs: int,
+                 available_local_storage_in_gbs: int,
+                 available_memory_in_gbs: int,
+                 compute_model: str,
+                 description_summary: str,
+                 hardware_type: str,
                  minimum_core_count: int,
-                 name: str):
+                 name: str,
+                 runtime_minimum_core_count: int,
+                 shape: str):
         """
         :param int available_core_count: The maximum number of CPU cores that can ben enabled on the DB Server for this Flex Component.
         :param int available_db_storage_in_gbs: The maximum  storage that can be enabled on the Storage Server for this Flex Component.
+        :param int available_local_storage_in_gbs: The maximum local storage that can be enabled on the DB Server for this Flex Component.
+        :param int available_memory_in_gbs: The maximum memory size that can be enabled on the DB Server for this Flex Component.
+        :param str compute_model: The compute model of the DB Server for this Flex Component.
+        :param str description_summary: The description summary for this Flex Component.
+        :param str hardware_type: The hardware type of the DB (Compute) or Storage (Cell) Server for this Flex Component.
         :param int minimum_core_count: The minimum number of CPU cores that can be enabled on the DB Server for this Flex Component.
         :param str name: A filter to return only resources that match the entire name given. The match is not case sensitive.
+        :param int runtime_minimum_core_count: The runtime minimum number of CPU cores that can be enabled for this Flex Component.
+        :param str shape: A filter to return only resources that belong to the entire shape name given. The match is not case sensitive.
         """
         pulumi.set(__self__, "available_core_count", available_core_count)
         pulumi.set(__self__, "available_db_storage_in_gbs", available_db_storage_in_gbs)
+        pulumi.set(__self__, "available_local_storage_in_gbs", available_local_storage_in_gbs)
+        pulumi.set(__self__, "available_memory_in_gbs", available_memory_in_gbs)
+        pulumi.set(__self__, "compute_model", compute_model)
+        pulumi.set(__self__, "description_summary", description_summary)
+        pulumi.set(__self__, "hardware_type", hardware_type)
         pulumi.set(__self__, "minimum_core_count", minimum_core_count)
         pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "runtime_minimum_core_count", runtime_minimum_core_count)
+        pulumi.set(__self__, "shape", shape)
 
     @property
     @pulumi.getter(name="availableCoreCount")
@@ -48353,6 +50426,46 @@ class GetFlexComponentsFlexComponentCollectionItemResult(dict):
         """
         return pulumi.get(self, "available_db_storage_in_gbs")
 
+    @property
+    @pulumi.getter(name="availableLocalStorageInGbs")
+    def available_local_storage_in_gbs(self) -> int:
+        """
+        The maximum local storage that can be enabled on the DB Server for this Flex Component.
+        """
+        return pulumi.get(self, "available_local_storage_in_gbs")
+
+    @property
+    @pulumi.getter(name="availableMemoryInGbs")
+    def available_memory_in_gbs(self) -> int:
+        """
+        The maximum memory size that can be enabled on the DB Server for this Flex Component.
+        """
+        return pulumi.get(self, "available_memory_in_gbs")
+
+    @property
+    @pulumi.getter(name="computeModel")
+    def compute_model(self) -> str:
+        """
+        The compute model of the DB Server for this Flex Component.
+        """
+        return pulumi.get(self, "compute_model")
+
+    @property
+    @pulumi.getter(name="descriptionSummary")
+    def description_summary(self) -> str:
+        """
+        The description summary for this Flex Component.
+        """
+        return pulumi.get(self, "description_summary")
+
+    @property
+    @pulumi.getter(name="hardwareType")
+    def hardware_type(self) -> str:
+        """
+        The hardware type of the DB (Compute) or Storage (Cell) Server for this Flex Component.
+        """
+        return pulumi.get(self, "hardware_type")
+
     @property
     @pulumi.getter(name="minimumCoreCount")
     def minimum_core_count(self) -> int:
@@ -48369,6 +50482,22 @@ class GetFlexComponentsFlexComponentCollectionItemResult(dict):
         """
         return pulumi.get(self, "name")
 
+    @property
+    @pulumi.getter(name="runtimeMinimumCoreCount")
+    def runtime_minimum_core_count(self) -> int:
+        """
+        The runtime minimum number of CPU cores that can be enabled for this Flex Component.
+        """
+        return pulumi.get(self, "runtime_minimum_core_count")
+
+    @property
+    @pulumi.getter
+    def shape(self) -> str:
+        """
+        A filter to return only resources that belong to the entire shape name given. The match is not case sensitive.
+        """
+        return pulumi.get(self, "shape")
+
 
 @pulumi.output_type
 class GetGiVersionMinorVersionsFilterResult(dict):
@@ -53485,6 +55614,7 @@ class GetVmClustersVmClusterResult(dict):
                  availability_domain: str,
                  cloud_automation_update_details: Sequence['outputs.GetVmClustersVmClusterCloudAutomationUpdateDetailResult'],
                  compartment_id: str,
+                 compute_model: str,
                  cpu_core_count: int,
                  cpus_enabled: int,
                  data_collection_options: Sequence['outputs.GetVmClustersVmClusterDataCollectionOptionResult'],
@@ -53495,6 +55625,7 @@ class GetVmClustersVmClusterResult(dict):
                  defined_tags: Mapping[str, str],
                  display_name: str,
                  exadata_infrastructure_id: str,
+                 exascale_db_storage_vault_id: str,
                  file_system_configuration_details: Sequence['outputs.GetVmClustersVmClusterFileSystemConfigurationDetailResult'],
                  freeform_tags: Mapping[str, str],
                  gi_version: str,
@@ -53510,14 +55641,17 @@ class GetVmClustersVmClusterResult(dict):
                  shape: str,
                  ssh_public_keys: Sequence[str],
                  state: str,
+                 storage_management_type: str,
                  system_version: str,
                  time_created: str,
                  time_zone: str,
-                 vm_cluster_network_id: str):
+                 vm_cluster_network_id: str,
+                 vm_cluster_type: str):
         """
         :param str availability_domain: The name of the availability domain that the VM cluster is located in.
         :param Sequence['GetVmClustersVmClusterCloudAutomationUpdateDetailArgs'] cloud_automation_update_details: Specifies the properties necessary for cloud automation updates. This includes modifying the apply update time preference, enabling or disabling early adoption, and enabling, modifying, or disabling the update freeze period.
         :param str compartment_id: The compartment [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
+        :param str compute_model: The compute model of the Autonomous Database. This is required if using the `computeCount` parameter. If using `cpuCoreCount` then it is an error to specify `computeModel` to a non-null value. ECPU compute model is the recommended model and OCPU compute model is legacy.
         :param int cpus_enabled: The number of enabled CPU cores.
         :param Sequence['GetVmClustersVmClusterDataCollectionOptionArgs'] data_collection_options: Indicates user preferences for the various diagnostic collection options for the VM cluster/Cloud VM cluster/VMBM DBCS.
         :param float data_storage_size_in_gb: Size of the DATA disk group in GBs.
@@ -53527,6 +55661,7 @@ class GetVmClustersVmClusterResult(dict):
         :param Mapping[str, str] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).
         :param str display_name: A filter to return only resources that match the entire display name given. The match is not case sensitive.
         :param str exadata_infrastructure_id: If provided, filters the results for the given Exadata Infrastructure.
+        :param str exascale_db_storage_vault_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Exadata Database Storage Vault.
         :param Sequence['GetVmClustersVmClusterFileSystemConfigurationDetailArgs'] file_system_configuration_details: Details of the file system configuration of the VM cluster.
         :param Mapping[str, str] freeform_tags: Free-form tags for this resource. Each tag is a simple key-value pair with no predefined name, type, or namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).  Example: `{"Department": "Finance"}`
         :param str gi_version: The Oracle Grid Infrastructure software version for the VM cluster.
@@ -53540,14 +55675,17 @@ class GetVmClustersVmClusterResult(dict):
         :param str shape: The shape of the Exadata infrastructure. The shape determines the amount of CPU, storage, and memory resources allocated to the instance.
         :param Sequence[str] ssh_public_keys: The public key portion of one or more key pairs used for SSH access to the VM cluster.
         :param str state: A filter to return only resources that match the given lifecycle state exactly.
+        :param str storage_management_type: Specifies whether the type of storage management for the VM cluster is ASM or Exascale.
         :param str system_version: Operating system version of the image.
         :param str time_created: The date and time that the VM cluster was created.
         :param str time_zone: The time zone of the Exadata infrastructure. For details, see [Exadata Infrastructure Time Zones](https://docs.cloud.oracle.com/iaas/Content/Database/References/timezones.htm).
         :param str vm_cluster_network_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the VM cluster network.
+        :param str vm_cluster_type: A filter to return only vmclusters that match the given vmcluster type exactly.
         """
         pulumi.set(__self__, "availability_domain", availability_domain)
         pulumi.set(__self__, "cloud_automation_update_details", cloud_automation_update_details)
         pulumi.set(__self__, "compartment_id", compartment_id)
+        pulumi.set(__self__, "compute_model", compute_model)
         pulumi.set(__self__, "cpu_core_count", cpu_core_count)
         pulumi.set(__self__, "cpus_enabled", cpus_enabled)
         pulumi.set(__self__, "data_collection_options", data_collection_options)
@@ -53558,6 +55696,7 @@ class GetVmClustersVmClusterResult(dict):
         pulumi.set(__self__, "defined_tags", defined_tags)
         pulumi.set(__self__, "display_name", display_name)
         pulumi.set(__self__, "exadata_infrastructure_id", exadata_infrastructure_id)
+        pulumi.set(__self__, "exascale_db_storage_vault_id", exascale_db_storage_vault_id)
         pulumi.set(__self__, "file_system_configuration_details", file_system_configuration_details)
         pulumi.set(__self__, "freeform_tags", freeform_tags)
         pulumi.set(__self__, "gi_version", gi_version)
@@ -53573,10 +55712,12 @@ class GetVmClustersVmClusterResult(dict):
         pulumi.set(__self__, "shape", shape)
         pulumi.set(__self__, "ssh_public_keys", ssh_public_keys)
         pulumi.set(__self__, "state", state)
+        pulumi.set(__self__, "storage_management_type", storage_management_type)
         pulumi.set(__self__, "system_version", system_version)
         pulumi.set(__self__, "time_created", time_created)
         pulumi.set(__self__, "time_zone", time_zone)
         pulumi.set(__self__, "vm_cluster_network_id", vm_cluster_network_id)
+        pulumi.set(__self__, "vm_cluster_type", vm_cluster_type)
 
     @property
     @pulumi.getter(name="availabilityDomain")
@@ -53602,6 +55743,14 @@ class GetVmClustersVmClusterResult(dict):
         """
         return pulumi.get(self, "compartment_id")
 
+    @property
+    @pulumi.getter(name="computeModel")
+    def compute_model(self) -> str:
+        """
+        The compute model of the Autonomous Database. This is required if using the `computeCount` parameter. If using `cpuCoreCount` then it is an error to specify `computeModel` to a non-null value. ECPU compute model is the recommended model and OCPU compute model is legacy.
+        """
+        return pulumi.get(self, "compute_model")
+
     @property
     @pulumi.getter(name="cpuCoreCount")
     def cpu_core_count(self) -> int:
@@ -53679,6 +55828,14 @@ class GetVmClustersVmClusterResult(dict):
         """
         return pulumi.get(self, "exadata_infrastructure_id")
 
+    @property
+    @pulumi.getter(name="exascaleDbStorageVaultId")
+    def exascale_db_storage_vault_id(self) -> str:
+        """
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Exadata Database Storage Vault.
+        """
+        return pulumi.get(self, "exascale_db_storage_vault_id")
+
     @property
     @pulumi.getter(name="fileSystemConfigurationDetails")
     def file_system_configuration_details(self) -> Sequence['outputs.GetVmClustersVmClusterFileSystemConfigurationDetailResult']:
@@ -53793,6 +55950,14 @@ class GetVmClustersVmClusterResult(dict):
         """
         return pulumi.get(self, "state")
 
+    @property
+    @pulumi.getter(name="storageManagementType")
+    def storage_management_type(self) -> str:
+        """
+        Specifies whether the type of storage management for the VM cluster is ASM or Exascale.
+        """
+        return pulumi.get(self, "storage_management_type")
+
     @property
     @pulumi.getter(name="systemVersion")
     def system_version(self) -> str:
@@ -53825,6 +55990,14 @@ class GetVmClustersVmClusterResult(dict):
         """
         return pulumi.get(self, "vm_cluster_network_id")
 
+    @property
+    @pulumi.getter(name="vmClusterType")
+    def vm_cluster_type(self) -> str:
+        """
+        A filter to return only vmclusters that match the given vmcluster type exactly.
+        """
+        return pulumi.get(self, "vm_cluster_type")
+
 
 @pulumi.output_type
 class GetVmClustersVmClusterCloudAutomationUpdateDetailResult(dict):