pulumi-oci 3.6.0a1756509375__py3-none-any.whl → 3.6.0a1757045455__py3-none-any.whl

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]]

pulumi_oci/mysql/get_mysql_backup.py

@@ -27,7 +27,7 @@ class GetMysqlBackupResult:
     """
     A collection of values returned by getMysqlBackup.
     """
-    def __init__(__self__, backup_id=None, backup_size_in_gbs=None, backup_type=None, compartment_id=None, creation_type=None, data_storage_size_in_gb=None, db_system_id=None, db_system_snapshot_summaries=None, db_system_snapshots=None, defined_tags=None, description=None, display_name=None, encrypt_datas=None, freeform_tags=None, id=None, immediate_source_backup_id=None, lifecycle_details=None, mysql_version=None, original_source_backup_id=None, retention_in_days=None, shape_name=None, soft_delete=None, source_details=None, state=None, system_tags=None, time_copy_created=None, time_created=None, time_updated=None):
+    def __init__(__self__, backup_id=None, backup_size_in_gbs=None, backup_type=None, backup_validation_details=None, compartment_id=None, creation_type=None, data_storage_size_in_gb=None, db_system_id=None, db_system_snapshot_summaries=None, db_system_snapshots=None, defined_tags=None, description=None, display_name=None, encrypt_datas=None, freeform_tags=None, id=None, immediate_source_backup_id=None, lifecycle_details=None, mysql_version=None, original_source_backup_id=None, retention_in_days=None, shape_name=None, soft_delete=None, source_details=None, state=None, system_tags=None, time_copy_created=None, time_created=None, time_updated=None, validate_backup_details=None, validate_trigger=None):
         if backup_id and not isinstance(backup_id, str):
             raise TypeError("Expected argument 'backup_id' to be a str")
         pulumi.set(__self__, "backup_id", backup_id)
@@ -37,6 +37,9 @@ class GetMysqlBackupResult:
         if backup_type and not isinstance(backup_type, str):
             raise TypeError("Expected argument 'backup_type' to be a str")
         pulumi.set(__self__, "backup_type", backup_type)
+        if backup_validation_details and not isinstance(backup_validation_details, list):
+            raise TypeError("Expected argument 'backup_validation_details' to be a list")
+        pulumi.set(__self__, "backup_validation_details", backup_validation_details)
         if compartment_id and not isinstance(compartment_id, str):
             raise TypeError("Expected argument 'compartment_id' to be a str")
         pulumi.set(__self__, "compartment_id", compartment_id)
@@ -112,6 +115,12 @@ class GetMysqlBackupResult:
         if time_updated and not isinstance(time_updated, str):
             raise TypeError("Expected argument 'time_updated' to be a str")
         pulumi.set(__self__, "time_updated", time_updated)
+        if validate_backup_details and not isinstance(validate_backup_details, list):
+            raise TypeError("Expected argument 'validate_backup_details' to be a list")
+        pulumi.set(__self__, "validate_backup_details", validate_backup_details)
+        if validate_trigger and not isinstance(validate_trigger, int):
+            raise TypeError("Expected argument 'validate_trigger' to be a int")
+        pulumi.set(__self__, "validate_trigger", validate_trigger)
 
     @_builtins.property
     @pulumi.getter(name="backupId")
@@ -134,6 +143,14 @@ class GetMysqlBackupResult:
         """
         return pulumi.get(self, "backup_type")
 
+    @_builtins.property
+    @pulumi.getter(name="backupValidationDetails")
+    def backup_validation_details(self) -> Sequence['outputs.GetMysqlBackupBackupValidationDetailResult']:
+        """
+        Backup validation details.
+        """
+        return pulumi.get(self, "backup_validation_details")
+
     @_builtins.property
     @pulumi.getter(name="compartmentId")
     def compartment_id(self) -> _builtins.str:
@@ -328,6 +345,16 @@ class GetMysqlBackupResult:
         """
         return pulumi.get(self, "time_updated")
 
+    @_builtins.property
+    @pulumi.getter(name="validateBackupDetails")
+    def validate_backup_details(self) -> Sequence['outputs.GetMysqlBackupValidateBackupDetailResult']:
+        return pulumi.get(self, "validate_backup_details")
+
+    @_builtins.property
+    @pulumi.getter(name="validateTrigger")
+    def validate_trigger(self) -> _builtins.int:
+        return pulumi.get(self, "validate_trigger")
+
 
 class AwaitableGetMysqlBackupResult(GetMysqlBackupResult):
     # pylint: disable=using-constant-test
@@ -338,6 +365,7 @@ class AwaitableGetMysqlBackupResult(GetMysqlBackupResult):
             backup_id=self.backup_id,
             backup_size_in_gbs=self.backup_size_in_gbs,
             backup_type=self.backup_type,
+            backup_validation_details=self.backup_validation_details,
             compartment_id=self.compartment_id,
             creation_type=self.creation_type,
             data_storage_size_in_gb=self.data_storage_size_in_gb,
@@ -362,7 +390,9 @@ class AwaitableGetMysqlBackupResult(GetMysqlBackupResult):
             system_tags=self.system_tags,
             time_copy_created=self.time_copy_created,
             time_created=self.time_created,
-            time_updated=self.time_updated)
+            time_updated=self.time_updated,
+            validate_backup_details=self.validate_backup_details,
+            validate_trigger=self.validate_trigger)
 
 
 def get_mysql_backup(backup_id: Optional[_builtins.str] = None,
@@ -393,6 +423,7 @@ def get_mysql_backup(backup_id: Optional[_builtins.str] = None,
         backup_id=pulumi.get(__ret__, 'backup_id'),
         backup_size_in_gbs=pulumi.get(__ret__, 'backup_size_in_gbs'),
         backup_type=pulumi.get(__ret__, 'backup_type'),
+        backup_validation_details=pulumi.get(__ret__, 'backup_validation_details'),
         compartment_id=pulumi.get(__ret__, 'compartment_id'),
         creation_type=pulumi.get(__ret__, 'creation_type'),
         data_storage_size_in_gb=pulumi.get(__ret__, 'data_storage_size_in_gb'),
@@ -417,7 +448,9 @@ def get_mysql_backup(backup_id: Optional[_builtins.str] = None,
         system_tags=pulumi.get(__ret__, 'system_tags'),
         time_copy_created=pulumi.get(__ret__, 'time_copy_created'),
         time_created=pulumi.get(__ret__, 'time_created'),
-        time_updated=pulumi.get(__ret__, 'time_updated'))
+        time_updated=pulumi.get(__ret__, 'time_updated'),
+        validate_backup_details=pulumi.get(__ret__, 'validate_backup_details'),
+        validate_trigger=pulumi.get(__ret__, 'validate_trigger'))
 def get_mysql_backup_output(backup_id: Optional[pulumi.Input[_builtins.str]] = None,
                             opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetMysqlBackupResult]:
     """
@@ -445,6 +478,7 @@ def get_mysql_backup_output(backup_id: Optional[pulumi.Input[_builtins.str]] = N
         backup_id=pulumi.get(__response__, 'backup_id'),
         backup_size_in_gbs=pulumi.get(__response__, 'backup_size_in_gbs'),
         backup_type=pulumi.get(__response__, 'backup_type'),
+        backup_validation_details=pulumi.get(__response__, 'backup_validation_details'),
         compartment_id=pulumi.get(__response__, 'compartment_id'),
         creation_type=pulumi.get(__response__, 'creation_type'),
         data_storage_size_in_gb=pulumi.get(__response__, 'data_storage_size_in_gb'),
@@ -469,4 +503,6 @@ def get_mysql_backup_output(backup_id: Optional[pulumi.Input[_builtins.str]] = N
         system_tags=pulumi.get(__response__, 'system_tags'),
         time_copy_created=pulumi.get(__response__, 'time_copy_created'),
         time_created=pulumi.get(__response__, 'time_created'),
-        time_updated=pulumi.get(__response__, 'time_updated')))
+        time_updated=pulumi.get(__response__, 'time_updated'),
+        validate_backup_details=pulumi.get(__response__, 'validate_backup_details'),
+        validate_trigger=pulumi.get(__response__, 'validate_trigger')))

pulumi_oci/mysql/get_mysql_backups.py

@@ -174,7 +174,7 @@ def get_mysql_backups(backup_id: Optional[_builtins.str] = None,
     import pulumi_oci as oci
 
     test_mysql_backups = oci.Mysql.get_mysql_backups(compartment_id=compartment_id,
-        backup_id=test_backup["id"],
+        backup_id=test_mysql_backup["id"],
         creation_type=mysql_backup_creation_type,
         db_system_id=test_db_system["id"],
         display_name=mysql_backup_display_name,
@@ -235,7 +235,7 @@ def get_mysql_backups_output(backup_id: Optional[pulumi.Input[Optional[_builtins
     import pulumi_oci as oci
 
     test_mysql_backups = oci.Mysql.get_mysql_backups(compartment_id=compartment_id,
-        backup_id=test_backup["id"],
+        backup_id=test_mysql_backup["id"],
         creation_type=mysql_backup_creation_type,
         db_system_id=test_db_system["id"],
         display_name=mysql_backup_display_name,