pulumi-oci 3.5.0a1756440723__py3-none-any.whl → 3.6.0a1757045455__py3-none-any.whl

pulumi_oci/database/get_exascale_db_storage_vault.py

@@ -27,13 +27,16 @@ class GetExascaleDbStorageVaultResult:
     """
     A collection of values returned by getExascaleDbStorageVault.
     """
-    def __init__(__self__, additional_flash_cache_in_percent=None, attached_shape_attributes=None, availability_domain=None, cluster_placement_group_id=None, compartment_id=None, defined_tags=None, description=None, display_name=None, exadata_infrastructure_id=None, exascale_db_storage_vault_id=None, freeform_tags=None, high_capacity_database_storages=None, id=None, lifecycle_details=None, state=None, subscription_id=None, system_tags=None, time_created=None, time_zone=None, vm_cluster_count=None, vm_cluster_ids=None):
+    def __init__(__self__, additional_flash_cache_in_percent=None, attached_shape_attributes=None, autoscale_limit_in_gbs=None, availability_domain=None, cluster_placement_group_id=None, compartment_id=None, defined_tags=None, description=None, display_name=None, exadata_infrastructure_id=None, exascale_db_storage_vault_id=None, freeform_tags=None, high_capacity_database_storages=None, id=None, is_autoscale_enabled=None, lifecycle_details=None, state=None, subscription_id=None, system_tags=None, time_created=None, time_zone=None, vm_cluster_count=None, vm_cluster_ids=None):
         if additional_flash_cache_in_percent and not isinstance(additional_flash_cache_in_percent, int):
             raise TypeError("Expected argument 'additional_flash_cache_in_percent' to be a int")
         pulumi.set(__self__, "additional_flash_cache_in_percent", additional_flash_cache_in_percent)
         if attached_shape_attributes and not isinstance(attached_shape_attributes, list):
             raise TypeError("Expected argument 'attached_shape_attributes' to be a list")
         pulumi.set(__self__, "attached_shape_attributes", attached_shape_attributes)
+        if autoscale_limit_in_gbs and not isinstance(autoscale_limit_in_gbs, int):
+            raise TypeError("Expected argument 'autoscale_limit_in_gbs' to be a int")
+        pulumi.set(__self__, "autoscale_limit_in_gbs", autoscale_limit_in_gbs)
         if availability_domain and not isinstance(availability_domain, str):
             raise TypeError("Expected argument 'availability_domain' to be a str")
         pulumi.set(__self__, "availability_domain", availability_domain)
@@ -67,6 +70,9 @@ class GetExascaleDbStorageVaultResult:
         if id and not isinstance(id, str):
             raise TypeError("Expected argument 'id' to be a str")
         pulumi.set(__self__, "id", id)
+        if is_autoscale_enabled and not isinstance(is_autoscale_enabled, bool):
+            raise TypeError("Expected argument 'is_autoscale_enabled' to be a bool")
+        pulumi.set(__self__, "is_autoscale_enabled", is_autoscale_enabled)
         if lifecycle_details and not isinstance(lifecycle_details, str):
             raise TypeError("Expected argument 'lifecycle_details' to be a str")
         pulumi.set(__self__, "lifecycle_details", lifecycle_details)
@@ -108,6 +114,14 @@ class GetExascaleDbStorageVaultResult:
         """
         return pulumi.get(self, "attached_shape_attributes")
 
+    @_builtins.property
+    @pulumi.getter(name="autoscaleLimitInGbs")
+    def autoscale_limit_in_gbs(self) -> _builtins.int:
+        """
+        Maximum limit storage size in gigabytes, that is applicable for the Database Storage Vault.
+        """
+        return pulumi.get(self, "autoscale_limit_in_gbs")
+
     @_builtins.property
     @pulumi.getter(name="availabilityDomain")
     def availability_domain(self) -> _builtins.str:
@@ -193,6 +207,14 @@ class GetExascaleDbStorageVaultResult:
         """
         return pulumi.get(self, "id")
 
+    @_builtins.property
+    @pulumi.getter(name="isAutoscaleEnabled")
+    def is_autoscale_enabled(self) -> _builtins.bool:
+        """
+        Indicates if autoscale feature is enabled for the Database Storage Vault. The default value is `FALSE`.
+        """
+        return pulumi.get(self, "is_autoscale_enabled")
+
     @_builtins.property
     @pulumi.getter(name="lifecycleDetails")
     def lifecycle_details(self) -> _builtins.str:
@@ -266,6 +288,7 @@ class AwaitableGetExascaleDbStorageVaultResult(GetExascaleDbStorageVaultResult):
         return GetExascaleDbStorageVaultResult(
             additional_flash_cache_in_percent=self.additional_flash_cache_in_percent,
             attached_shape_attributes=self.attached_shape_attributes,
+            autoscale_limit_in_gbs=self.autoscale_limit_in_gbs,
             availability_domain=self.availability_domain,
             cluster_placement_group_id=self.cluster_placement_group_id,
             compartment_id=self.compartment_id,
@@ -277,6 +300,7 @@ class AwaitableGetExascaleDbStorageVaultResult(GetExascaleDbStorageVaultResult):
             freeform_tags=self.freeform_tags,
             high_capacity_database_storages=self.high_capacity_database_storages,
             id=self.id,
+            is_autoscale_enabled=self.is_autoscale_enabled,
             lifecycle_details=self.lifecycle_details,
             state=self.state,
             subscription_id=self.subscription_id,
@@ -314,6 +338,7 @@ def get_exascale_db_storage_vault(exascale_db_storage_vault_id: Optional[_builti
     return AwaitableGetExascaleDbStorageVaultResult(
         additional_flash_cache_in_percent=pulumi.get(__ret__, 'additional_flash_cache_in_percent'),
         attached_shape_attributes=pulumi.get(__ret__, 'attached_shape_attributes'),
+        autoscale_limit_in_gbs=pulumi.get(__ret__, 'autoscale_limit_in_gbs'),
         availability_domain=pulumi.get(__ret__, 'availability_domain'),
         cluster_placement_group_id=pulumi.get(__ret__, 'cluster_placement_group_id'),
         compartment_id=pulumi.get(__ret__, 'compartment_id'),
@@ -325,6 +350,7 @@ def get_exascale_db_storage_vault(exascale_db_storage_vault_id: Optional[_builti
         freeform_tags=pulumi.get(__ret__, 'freeform_tags'),
         high_capacity_database_storages=pulumi.get(__ret__, 'high_capacity_database_storages'),
         id=pulumi.get(__ret__, 'id'),
+        is_autoscale_enabled=pulumi.get(__ret__, 'is_autoscale_enabled'),
         lifecycle_details=pulumi.get(__ret__, 'lifecycle_details'),
         state=pulumi.get(__ret__, 'state'),
         subscription_id=pulumi.get(__ret__, 'subscription_id'),
@@ -359,6 +385,7 @@ def get_exascale_db_storage_vault_output(exascale_db_storage_vault_id: Optional[
     return __ret__.apply(lambda __response__: GetExascaleDbStorageVaultResult(
         additional_flash_cache_in_percent=pulumi.get(__response__, 'additional_flash_cache_in_percent'),
         attached_shape_attributes=pulumi.get(__response__, 'attached_shape_attributes'),
+        autoscale_limit_in_gbs=pulumi.get(__response__, 'autoscale_limit_in_gbs'),
         availability_domain=pulumi.get(__response__, 'availability_domain'),
         cluster_placement_group_id=pulumi.get(__response__, 'cluster_placement_group_id'),
         compartment_id=pulumi.get(__response__, 'compartment_id'),
@@ -370,6 +397,7 @@ def get_exascale_db_storage_vault_output(exascale_db_storage_vault_id: Optional[
         freeform_tags=pulumi.get(__response__, 'freeform_tags'),
         high_capacity_database_storages=pulumi.get(__response__, 'high_capacity_database_storages'),
         id=pulumi.get(__response__, 'id'),
+        is_autoscale_enabled=pulumi.get(__response__, 'is_autoscale_enabled'),
         lifecycle_details=pulumi.get(__response__, 'lifecycle_details'),
         state=pulumi.get(__response__, 'state'),
         subscription_id=pulumi.get(__response__, 'subscription_id'),

pulumi_oci/database/outputs.py

@@ -5401,10 +5401,14 @@ class AutonomousDatabaseResourcePoolSummary(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "isDisabled":
+        if key == "availableComputeCapacity":
+            suggest = "available_compute_capacity"
+        elif key == "isDisabled":
             suggest = "is_disabled"
         elif key == "poolSize":
             suggest = "pool_size"
+        elif key == "totalComputeCapacity":
+            suggest = "total_compute_capacity"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in AutonomousDatabaseResourcePoolSummary. Access the value via the '{suggest}' property getter instead.")
@@ -5418,16 +5422,32 @@ class AutonomousDatabaseResourcePoolSummary(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 available_compute_capacity: Optional[_builtins.int] = None,
                  is_disabled: Optional[_builtins.bool] = None,
-                 pool_size: Optional[_builtins.int] = None):
+                 pool_size: Optional[_builtins.int] = None,
+                 total_compute_capacity: Optional[_builtins.int] = None):
         """
+        :param _builtins.int available_compute_capacity: Available capacity left for new elastic pool members provision
         :param _builtins.bool is_disabled: (Updatable) Indicates if the resource pool should be deleted for the Autonomous Database.
         :param _builtins.int pool_size: (Updatable) Resource pool size.
+        :param _builtins.int total_compute_capacity: Resource Pool total capacity, it's currently 4x of pool size
         """
+        if available_compute_capacity is not None:
+            pulumi.set(__self__, "available_compute_capacity", available_compute_capacity)
         if is_disabled is not None:
             pulumi.set(__self__, "is_disabled", is_disabled)
         if pool_size is not None:
             pulumi.set(__self__, "pool_size", pool_size)
+        if total_compute_capacity is not None:
+            pulumi.set(__self__, "total_compute_capacity", total_compute_capacity)
+
+    @_builtins.property
+    @pulumi.getter(name="availableComputeCapacity")
+    def available_compute_capacity(self) -> Optional[_builtins.int]:
+        """
+        Available capacity left for new elastic pool members provision
+        """
+        return pulumi.get(self, "available_compute_capacity")
 
     @_builtins.property
     @pulumi.getter(name="isDisabled")
@@ -5445,6 +5465,14 @@ class AutonomousDatabaseResourcePoolSummary(dict):
         """
         return pulumi.get(self, "pool_size")
 
+    @_builtins.property
+    @pulumi.getter(name="totalComputeCapacity")
+    def total_compute_capacity(self) -> Optional[_builtins.int]:
+        """
+        Resource Pool total capacity, it's currently 4x of pool size
+        """
+        return pulumi.get(self, "total_compute_capacity")
+
 
 @pulumi.output_type
 class AutonomousDatabaseScheduledOperation(dict):
@@ -24700,14 +24728,28 @@ class GetAutonomousDatabaseResourcePoolMembersResourcePoolMemberCollectionItemRe
 @pulumi.output_type
 class GetAutonomousDatabaseResourcePoolSummaryResult(dict):
     def __init__(__self__, *,
+                 available_compute_capacity: _builtins.int,
                  is_disabled: _builtins.bool,
-                 pool_size: _builtins.int):
+                 pool_size: _builtins.int,
+                 total_compute_capacity: _builtins.int):
         """
+        :param _builtins.int available_compute_capacity: Available capacity left for new elastic pool members provision
         :param _builtins.bool is_disabled: Indicates if the resource pool should be deleted for the Autonomous Database.
         :param _builtins.int pool_size: Resource pool size.
+        :param _builtins.int total_compute_capacity: Resource Pool total capacity, it's currently 4x of pool size
         """
+        pulumi.set(__self__, "available_compute_capacity", available_compute_capacity)
         pulumi.set(__self__, "is_disabled", is_disabled)
         pulumi.set(__self__, "pool_size", pool_size)
+        pulumi.set(__self__, "total_compute_capacity", total_compute_capacity)
+
+    @_builtins.property
+    @pulumi.getter(name="availableComputeCapacity")
+    def available_compute_capacity(self) -> _builtins.int:
+        """
+        Available capacity left for new elastic pool members provision
+        """
+        return pulumi.get(self, "available_compute_capacity")
 
     @_builtins.property
     @pulumi.getter(name="isDisabled")
@@ -24725,6 +24767,14 @@ class GetAutonomousDatabaseResourcePoolSummaryResult(dict):
         """
         return pulumi.get(self, "pool_size")
 
+    @_builtins.property
+    @pulumi.getter(name="totalComputeCapacity")
+    def total_compute_capacity(self) -> _builtins.int:
+        """
+        Resource Pool total capacity, it's currently 4x of pool size
+        """
+        return pulumi.get(self, "total_compute_capacity")
+
 
 @pulumi.output_type
 class GetAutonomousDatabaseScheduledOperationResult(dict):
@@ -27807,14 +27857,28 @@ class GetAutonomousDatabasesAutonomousDatabaseRemoteDisasterRecoveryConfiguratio
 @pulumi.output_type
 class GetAutonomousDatabasesAutonomousDatabaseResourcePoolSummaryResult(dict):
     def __init__(__self__, *,
+                 available_compute_capacity: _builtins.int,
                  is_disabled: _builtins.bool,
-                 pool_size: _builtins.int):
+                 pool_size: _builtins.int,
+                 total_compute_capacity: _builtins.int):
         """
+        :param _builtins.int available_compute_capacity: Available capacity left for new elastic pool members provision
         :param _builtins.bool is_disabled: Indicates if the resource pool should be deleted for the Autonomous Database.
         :param _builtins.int pool_size: Resource pool size.
+        :param _builtins.int total_compute_capacity: Resource Pool total capacity, it's currently 4x of pool size
         """
+        pulumi.set(__self__, "available_compute_capacity", available_compute_capacity)
         pulumi.set(__self__, "is_disabled", is_disabled)
         pulumi.set(__self__, "pool_size", pool_size)
+        pulumi.set(__self__, "total_compute_capacity", total_compute_capacity)
+
+    @_builtins.property
+    @pulumi.getter(name="availableComputeCapacity")
+    def available_compute_capacity(self) -> _builtins.int:
+        """
+        Available capacity left for new elastic pool members provision
+        """
+        return pulumi.get(self, "available_compute_capacity")
 
     @_builtins.property
     @pulumi.getter(name="isDisabled")
@@ -27832,6 +27896,14 @@ class GetAutonomousDatabasesAutonomousDatabaseResourcePoolSummaryResult(dict):
         """
         return pulumi.get(self, "pool_size")
 
+    @_builtins.property
+    @pulumi.getter(name="totalComputeCapacity")
+    def total_compute_capacity(self) -> _builtins.int:
+        """
+        Resource Pool total capacity, it's currently 4x of pool size
+        """
+        return pulumi.get(self, "total_compute_capacity")
+
 
 @pulumi.output_type
 class GetAutonomousDatabasesAutonomousDatabaseScheduledOperationResult(dict):
@@ -30533,14 +30605,28 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseRemoteDisasterRecoveryConfig
 @pulumi.output_type
 class GetAutonomousDatabasesClonesAutonomousDatabaseResourcePoolSummaryResult(dict):
     def __init__(__self__, *,
+                 available_compute_capacity: _builtins.int,
                  is_disabled: _builtins.bool,
-                 pool_size: _builtins.int):
+                 pool_size: _builtins.int,
+                 total_compute_capacity: _builtins.int):
         """
+        :param _builtins.int available_compute_capacity: Available capacity left for new elastic pool members provision
         :param _builtins.bool is_disabled: Indicates if the resource pool should be deleted for the Autonomous Database.
         :param _builtins.int pool_size: Resource pool size.
+        :param _builtins.int total_compute_capacity: Resource Pool total capacity, it's currently 4x of pool size
         """
+        pulumi.set(__self__, "available_compute_capacity", available_compute_capacity)
         pulumi.set(__self__, "is_disabled", is_disabled)
         pulumi.set(__self__, "pool_size", pool_size)
+        pulumi.set(__self__, "total_compute_capacity", total_compute_capacity)
+
+    @_builtins.property
+    @pulumi.getter(name="availableComputeCapacity")
+    def available_compute_capacity(self) -> _builtins.int:
+        """
+        Available capacity left for new elastic pool members provision
+        """
+        return pulumi.get(self, "available_compute_capacity")
 
     @_builtins.property
     @pulumi.getter(name="isDisabled")
@@ -30558,6 +30644,14 @@ class GetAutonomousDatabasesClonesAutonomousDatabaseResourcePoolSummaryResult(di
         """
         return pulumi.get(self, "pool_size")
 
+    @_builtins.property
+    @pulumi.getter(name="totalComputeCapacity")
+    def total_compute_capacity(self) -> _builtins.int:
+        """
+        Resource Pool total capacity, it's currently 4x of pool size
+        """
+        return pulumi.get(self, "total_compute_capacity")
+
 
 @pulumi.output_type
 class GetAutonomousDatabasesClonesAutonomousDatabaseScheduledOperationResult(dict):
@@ -52411,6 +52505,7 @@ class GetExascaleDbStorageVaultsExascaleDbStorageVaultResult(dict):
     def __init__(__self__, *,
                  additional_flash_cache_in_percent: _builtins.int,
                  attached_shape_attributes: Sequence[_builtins.str],
+                 autoscale_limit_in_gbs: _builtins.int,
                  availability_domain: _builtins.str,
                  cluster_placement_group_id: _builtins.str,
                  compartment_id: _builtins.str,
@@ -52421,6 +52516,7 @@ class GetExascaleDbStorageVaultsExascaleDbStorageVaultResult(dict):
                  freeform_tags: Mapping[str, _builtins.str],
                  high_capacity_database_storages: Sequence['outputs.GetExascaleDbStorageVaultsExascaleDbStorageVaultHighCapacityDatabaseStorageResult'],
                  id: _builtins.str,
+                 is_autoscale_enabled: _builtins.bool,
                  lifecycle_details: _builtins.str,
                  state: _builtins.str,
                  subscription_id: _builtins.str,
@@ -52432,6 +52528,7 @@ class GetExascaleDbStorageVaultsExascaleDbStorageVaultResult(dict):
         """
         :param _builtins.int additional_flash_cache_in_percent: The size of additional Flash Cache in percentage of High Capacity database storage.
         :param Sequence[_builtins.str] attached_shape_attributes: A filter to return only Exadata Database Storage Vaults which match the given attachedShapeAttributes or has null attachedShapeAttributes
+        :param _builtins.int autoscale_limit_in_gbs: Maximum limit storage size in gigabytes, that is applicable for the Database Storage Vault.
         :param _builtins.str availability_domain: The name of the availability domain in which the Exadata Database Storage Vault is located.
         :param _builtins.str cluster_placement_group_id: A filter to return only resources that match the given cluster placement group ID exactly.
         :param _builtins.str compartment_id: The compartment [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
@@ -52442,6 +52539,7 @@ class GetExascaleDbStorageVaultsExascaleDbStorageVaultResult(dict):
         :param Mapping[str, _builtins.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 _builtins.str id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the Exadata Database Storage Vault.
+        :param _builtins.bool is_autoscale_enabled: Indicates if autoscale feature is enabled for the Database Storage Vault. The default value is `FALSE`.
         :param _builtins.str lifecycle_details: Additional information about the current lifecycle state.
         :param _builtins.str state: A filter to return only Exadata Database Storage Vaults that match the given lifecycle state exactly.
         :param _builtins.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.
@@ -52453,6 +52551,7 @@ class GetExascaleDbStorageVaultsExascaleDbStorageVaultResult(dict):
         """
         pulumi.set(__self__, "additional_flash_cache_in_percent", additional_flash_cache_in_percent)
         pulumi.set(__self__, "attached_shape_attributes", attached_shape_attributes)
+        pulumi.set(__self__, "autoscale_limit_in_gbs", autoscale_limit_in_gbs)
         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)
@@ -52463,6 +52562,7 @@ class GetExascaleDbStorageVaultsExascaleDbStorageVaultResult(dict):
         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__, "is_autoscale_enabled", is_autoscale_enabled)
         pulumi.set(__self__, "lifecycle_details", lifecycle_details)
         pulumi.set(__self__, "state", state)
         pulumi.set(__self__, "subscription_id", subscription_id)
@@ -52488,6 +52588,14 @@ class GetExascaleDbStorageVaultsExascaleDbStorageVaultResult(dict):
         """
         return pulumi.get(self, "attached_shape_attributes")
 
+    @_builtins.property
+    @pulumi.getter(name="autoscaleLimitInGbs")
+    def autoscale_limit_in_gbs(self) -> _builtins.int:
+        """
+        Maximum limit storage size in gigabytes, that is applicable for the Database Storage Vault.
+        """
+        return pulumi.get(self, "autoscale_limit_in_gbs")
+
     @_builtins.property
     @pulumi.getter(name="availabilityDomain")
     def availability_domain(self) -> _builtins.str:
@@ -52568,6 +52676,14 @@ class GetExascaleDbStorageVaultsExascaleDbStorageVaultResult(dict):
         """
         return pulumi.get(self, "id")
 
+    @_builtins.property
+    @pulumi.getter(name="isAutoscaleEnabled")
+    def is_autoscale_enabled(self) -> _builtins.bool:
+        """
+        Indicates if autoscale feature is enabled for the Database Storage Vault. The default value is `FALSE`.
+        """
+        return pulumi.get(self, "is_autoscale_enabled")
+
     @_builtins.property
     @pulumi.getter(name="lifecycleDetails")
     def lifecycle_details(self) -> _builtins.str:

pulumi_oci/mysql/_inputs.py

@@ -27,6 +27,10 @@ __all__ = [
     'ChannelTargetFilterArgsDict',
     'HeatWaveClusterClusterNodeArgs',
     'HeatWaveClusterClusterNodeArgsDict',
+    'MysqlBackupBackupValidationDetailArgs',
+    'MysqlBackupBackupValidationDetailArgsDict',
+    'MysqlBackupBackupValidationDetailPreparedBackupDetailArgs',
+    'MysqlBackupBackupValidationDetailPreparedBackupDetailArgsDict',
     'MysqlBackupDbSystemSnapshotArgs',
     'MysqlBackupDbSystemSnapshotArgsDict',
     'MysqlBackupDbSystemSnapshotBackupPolicyArgs',
@@ -57,6 +61,8 @@ __all__ = [
     'MysqlBackupEncryptDataArgsDict',
     'MysqlBackupSourceDetailsArgs',
     'MysqlBackupSourceDetailsArgsDict',
+    'MysqlBackupValidateBackupDetailArgs',
+    'MysqlBackupValidateBackupDetailArgsDict',
     'MysqlConfigurationInitVariablesArgs',
     'MysqlConfigurationInitVariablesArgsDict',
     'MysqlConfigurationVariablesArgs',
@@ -756,6 +762,190 @@ class HeatWaveClusterClusterNodeArgs:
         pulumi.set(self, "time_updated", value)
 
 
+if not MYPY:
+    class MysqlBackupBackupValidationDetailArgsDict(TypedDict):
+        backup_preparation_status: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Indicates whether the backup has been prepared successfully.  PREPARED: The backup is prepared one. NOT_PREPARED: The backup is not prepared.
+        """
+        error_message: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Error message if the backup validation has failed.
+        """
+        estimated_restore_duration: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The estimated restore duration of the backup.
+        """
+        prepared_backup_details: NotRequired[pulumi.Input[Sequence[pulumi.Input['MysqlBackupBackupValidationDetailPreparedBackupDetailArgsDict']]]]
+        """
+        Prepared backup details.
+        """
+        time_last_validated: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The date and time of the most recent validation performed on the backup.
+        """
+        validation_status: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The status of backup validation:  NOT_VALIDATED (Default): The backup has not been validated.  VALIDATED: The backup has been validated successfully.  NEEDS_ATTENTION: The backup validation failed due to a transient issue. Validation should be retried.  FAILED: The backup cannot be restored.
+        """
+elif False:
+    MysqlBackupBackupValidationDetailArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class MysqlBackupBackupValidationDetailArgs:
+    def __init__(__self__, *,
+                 backup_preparation_status: Optional[pulumi.Input[_builtins.str]] = None,
+                 error_message: Optional[pulumi.Input[_builtins.str]] = None,
+                 estimated_restore_duration: Optional[pulumi.Input[_builtins.str]] = None,
+                 prepared_backup_details: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupBackupValidationDetailPreparedBackupDetailArgs']]]] = None,
+                 time_last_validated: Optional[pulumi.Input[_builtins.str]] = None,
+                 validation_status: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] backup_preparation_status: Indicates whether the backup has been prepared successfully.  PREPARED: The backup is prepared one. NOT_PREPARED: The backup is not prepared.
+        :param pulumi.Input[_builtins.str] error_message: Error message if the backup validation has failed.
+        :param pulumi.Input[_builtins.str] estimated_restore_duration: The estimated restore duration of the backup.
+        :param pulumi.Input[Sequence[pulumi.Input['MysqlBackupBackupValidationDetailPreparedBackupDetailArgs']]] prepared_backup_details: Prepared backup details.
+        :param pulumi.Input[_builtins.str] time_last_validated: The date and time of the most recent validation performed on the backup.
+        :param pulumi.Input[_builtins.str] validation_status: The status of backup validation:  NOT_VALIDATED (Default): The backup has not been validated.  VALIDATED: The backup has been validated successfully.  NEEDS_ATTENTION: The backup validation failed due to a transient issue. Validation should be retried.  FAILED: The backup cannot be restored.
+        """
+        if backup_preparation_status is not None:
+            pulumi.set(__self__, "backup_preparation_status", backup_preparation_status)
+        if error_message is not None:
+            pulumi.set(__self__, "error_message", error_message)
+        if estimated_restore_duration is not None:
+            pulumi.set(__self__, "estimated_restore_duration", estimated_restore_duration)
+        if prepared_backup_details is not None:
+            pulumi.set(__self__, "prepared_backup_details", prepared_backup_details)
+        if time_last_validated is not None:
+            pulumi.set(__self__, "time_last_validated", time_last_validated)
+        if validation_status is not None:
+            pulumi.set(__self__, "validation_status", validation_status)
+
+    @_builtins.property
+    @pulumi.getter(name="backupPreparationStatus")
+    def backup_preparation_status(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Indicates whether the backup has been prepared successfully.  PREPARED: The backup is prepared one. NOT_PREPARED: The backup is not prepared.
+        """
+        return pulumi.get(self, "backup_preparation_status")
+
+    @backup_preparation_status.setter
+    def backup_preparation_status(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "backup_preparation_status", value)
+
+    @_builtins.property
+    @pulumi.getter(name="errorMessage")
+    def error_message(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Error message if the backup validation has failed.
+        """
+        return pulumi.get(self, "error_message")
+
+    @error_message.setter
+    def error_message(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "error_message", value)
+
+    @_builtins.property
+    @pulumi.getter(name="estimatedRestoreDuration")
+    def estimated_restore_duration(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The estimated restore duration of the backup.
+        """
+        return pulumi.get(self, "estimated_restore_duration")
+
+    @estimated_restore_duration.setter
+    def estimated_restore_duration(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "estimated_restore_duration", value)
+
+    @_builtins.property
+    @pulumi.getter(name="preparedBackupDetails")
+    def prepared_backup_details(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupBackupValidationDetailPreparedBackupDetailArgs']]]]:
+        """
+        Prepared backup details.
+        """
+        return pulumi.get(self, "prepared_backup_details")
+
+    @prepared_backup_details.setter
+    def prepared_backup_details(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupBackupValidationDetailPreparedBackupDetailArgs']]]]):
+        pulumi.set(self, "prepared_backup_details", value)
+
+    @_builtins.property
+    @pulumi.getter(name="timeLastValidated")
+    def time_last_validated(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The date and time of the most recent validation performed on the backup.
+        """
+        return pulumi.get(self, "time_last_validated")
+
+    @time_last_validated.setter
+    def time_last_validated(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "time_last_validated", value)
+
+    @_builtins.property
+    @pulumi.getter(name="validationStatus")
+    def validation_status(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The status of backup validation:  NOT_VALIDATED (Default): The backup has not been validated.  VALIDATED: The backup has been validated successfully.  NEEDS_ATTENTION: The backup validation failed due to a transient issue. Validation should be retried.  FAILED: The backup cannot be restored.
+        """
+        return pulumi.get(self, "validation_status")
+
+    @validation_status.setter
+    def validation_status(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "validation_status", value)
+
+
+if not MYPY:
+    class MysqlBackupBackupValidationDetailPreparedBackupDetailArgsDict(TypedDict):
+        prepared_backup_restore_reduction_in_minutes: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The estimated time saving when this prepared backup is restored.
+        """
+        time_prepared: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The date and time the backup was prepared.
+        """
+elif False:
+    MysqlBackupBackupValidationDetailPreparedBackupDetailArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class MysqlBackupBackupValidationDetailPreparedBackupDetailArgs:
+    def __init__(__self__, *,
+                 prepared_backup_restore_reduction_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
+                 time_prepared: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.int] prepared_backup_restore_reduction_in_minutes: The estimated time saving when this prepared backup is restored.
+        :param pulumi.Input[_builtins.str] time_prepared: The date and time the backup was prepared.
+        """
+        if prepared_backup_restore_reduction_in_minutes is not None:
+            pulumi.set(__self__, "prepared_backup_restore_reduction_in_minutes", prepared_backup_restore_reduction_in_minutes)
+        if time_prepared is not None:
+            pulumi.set(__self__, "time_prepared", time_prepared)
+
+    @_builtins.property
+    @pulumi.getter(name="preparedBackupRestoreReductionInMinutes")
+    def prepared_backup_restore_reduction_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The estimated time saving when this prepared backup is restored.
+        """
+        return pulumi.get(self, "prepared_backup_restore_reduction_in_minutes")
+
+    @prepared_backup_restore_reduction_in_minutes.setter
+    def prepared_backup_restore_reduction_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "prepared_backup_restore_reduction_in_minutes", value)
+
+    @_builtins.property
+    @pulumi.getter(name="timePrepared")
+    def time_prepared(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The date and time the backup was prepared.
+        """
+        return pulumi.get(self, "time_prepared")
+
+    @time_prepared.setter
+    def time_prepared(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "time_prepared", value)
+
+
 if not MYPY:
     class MysqlBackupDbSystemSnapshotArgsDict(TypedDict):
         admin_username: NotRequired[pulumi.Input[_builtins.str]]
@@ -2512,6 +2702,37 @@ class MysqlBackupSourceDetailsArgs:
         pulumi.set(self, "region", value)
 
 
+if not MYPY:
+    class MysqlBackupValidateBackupDetailArgsDict(TypedDict):
+        is_prepared_backup_required: pulumi.Input[_builtins.bool]
+        """
+        Specifies whether the backup needs to be prepared for fast restore or not. Set to true to prepare the backup **Note:** Prepare backup is a one time operation, therefore this field can be set to true only once.
+        """
+elif False:
+    MysqlBackupValidateBackupDetailArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class MysqlBackupValidateBackupDetailArgs:
+    def __init__(__self__, *,
+                 is_prepared_backup_required: pulumi.Input[_builtins.bool]):
+        """
+        :param pulumi.Input[_builtins.bool] is_prepared_backup_required: Specifies whether the backup needs to be prepared for fast restore or not. Set to true to prepare the backup **Note:** Prepare backup is a one time operation, therefore this field can be set to true only once.
+        """
+        pulumi.set(__self__, "is_prepared_backup_required", is_prepared_backup_required)
+
+    @_builtins.property
+    @pulumi.getter(name="isPreparedBackupRequired")
+    def is_prepared_backup_required(self) -> pulumi.Input[_builtins.bool]:
+        """
+        Specifies whether the backup needs to be prepared for fast restore or not. Set to true to prepare the backup **Note:** Prepare backup is a one time operation, therefore this field can be set to true only once.
+        """
+        return pulumi.get(self, "is_prepared_backup_required")
+
+    @is_prepared_backup_required.setter
+    def is_prepared_backup_required(self, value: pulumi.Input[_builtins.bool]):
+        pulumi.set(self, "is_prepared_backup_required", value)
+
+
 if not MYPY:
     class MysqlConfigurationInitVariablesArgsDict(TypedDict):
         lower_case_table_names: NotRequired[pulumi.Input[_builtins.str]]