pulumi-oci 3.5.0a1756363728__py3-none-any.whl → 3.6.0__py3-none-any.whl

pulumi_oci/goldengate/outputs.py

@@ -5786,6 +5786,7 @@ class GetDeploymentPeersDeploymentPeerCollectionItemResult(dict):
                  region: _builtins.str,
                  state: _builtins.str,
                  time_created: _builtins.str,
+                 time_last_synced: _builtins.str,
                  time_role_changed: _builtins.str,
                  time_updated: _builtins.str):
         """
@@ -5798,6 +5799,7 @@ class GetDeploymentPeersDeploymentPeerCollectionItemResult(dict):
         :param _builtins.str region: The name of the region. e.g.: us-ashburn-1 If the region is not provided, backend will default to the default region.
         :param _builtins.str state: A filter to return only the resources that match the 'lifecycleState' given.
         :param _builtins.str time_created: The time the resource was created. The format is defined by [RFC3339](https://tools.ietf.org/html/rfc3339), such as `2016-08-25T21:10:29.600Z`.
+        :param _builtins.str time_last_synced: The time of the last data synchronization from the primary to the standby peer. [RFC3339](https://tools.ietf.org/html/rfc3339), such as `2016-08-25T21:10:29.600Z`.
         :param _builtins.str time_role_changed: The time of the last role change. The format is defined by [RFC3339](https://tools.ietf.org/html/rfc3339), such as `2016-08-25T21:10:29.600Z`.
         :param _builtins.str time_updated: The time the resource was last updated. The format is defined by [RFC3339](https://tools.ietf.org/html/rfc3339), such as `2016-08-25T21:10:29.600Z`.
         """
@@ -5810,6 +5812,7 @@ class GetDeploymentPeersDeploymentPeerCollectionItemResult(dict):
         pulumi.set(__self__, "region", region)
         pulumi.set(__self__, "state", state)
         pulumi.set(__self__, "time_created", time_created)
+        pulumi.set(__self__, "time_last_synced", time_last_synced)
         pulumi.set(__self__, "time_role_changed", time_role_changed)
         pulumi.set(__self__, "time_updated", time_updated)
 
@@ -5885,6 +5888,14 @@ class GetDeploymentPeersDeploymentPeerCollectionItemResult(dict):
         """
         return pulumi.get(self, "time_created")
 
+    @_builtins.property
+    @pulumi.getter(name="timeLastSynced")
+    def time_last_synced(self) -> _builtins.str:
+        """
+        The time of the last data synchronization from the primary to the standby peer. [RFC3339](https://tools.ietf.org/html/rfc3339), such as `2016-08-25T21:10:29.600Z`.
+        """
+        return pulumi.get(self, "time_last_synced")
+
     @_builtins.property
     @pulumi.getter(name="timeRoleChanged")
     def time_role_changed(self) -> _builtins.str:
@@ -6697,6 +6708,7 @@ class GetDeploymentsDeploymentCollectionItemResult(dict):
     def __init__(__self__, *,
                  availability_domain: _builtins.str,
                  backup_schedules: Sequence['outputs.GetDeploymentsDeploymentCollectionItemBackupScheduleResult'],
+                 byol_cpu_core_count_limit: _builtins.int,
                  category: _builtins.str,
                  compartment_id: _builtins.str,
                  cpu_core_count: _builtins.int,
@@ -6715,6 +6727,7 @@ class GetDeploymentsDeploymentCollectionItemResult(dict):
                  id: _builtins.str,
                  ingress_ips: Sequence['outputs.GetDeploymentsDeploymentCollectionItemIngressIpResult'],
                  is_auto_scaling_enabled: _builtins.bool,
+                 is_byol_cpu_core_count_limit_enabled: _builtins.bool,
                  is_healthy: _builtins.bool,
                  is_latest_version: _builtins.bool,
                  is_lock_override: _builtins.bool,
@@ -6751,6 +6764,7 @@ class GetDeploymentsDeploymentCollectionItemResult(dict):
         """
         :param _builtins.str availability_domain: The availability domain of a placement.
         :param Sequence['GetDeploymentsDeploymentCollectionItemBackupScheduleArgs'] backup_schedules: Defines the schedule of the deployment backup.
+        :param _builtins.int byol_cpu_core_count_limit: The maximum number of CPUs allowed with a 'Bring Your Own License' (BYOL) license type. Any CPU usage above this limit is considered as License Included and billed.
         :param _builtins.str category: The deployment category defines the broad separation of the deployment type into three categories. Currently the separation is 'DATA_REPLICATION', 'STREAM_ANALYTICS' and 'DATA_TRANSFORMS'.
         :param _builtins.str compartment_id: The OCID of the compartment that contains the work request. Work requests should be scoped  to the same compartment as the resource the work request affects. If the work request concerns  multiple resources, and those resources are not in the same compartment, it is up to the service team  to pick the primary resource whose compartment should be used.
         :param _builtins.int cpu_core_count: The Minimum number of OCPUs to be made available for this Deployment.
@@ -6758,7 +6772,7 @@ class GetDeploymentsDeploymentCollectionItemResult(dict):
         :param _builtins.str deployment_backup_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the backup being referenced.
         :param Sequence['GetDeploymentsDeploymentCollectionItemDeploymentDiagnosticDataArgs'] deployment_diagnostic_datas: Information regarding the deployment diagnostic collection
         :param _builtins.str deployment_role: The type of the deployment role.
-        :param _builtins.str deployment_type: The type of deployment, which can be any one of the Allowed values.  NOTE: Use of the value 'OGG' is maintained for backward compatibility purposes.  Its use is discouraged in favor of 'DATABASE_ORACLE'.
+        :param _builtins.str deployment_type: A filter that returns only the resources matching the specified 'deploymentType'.
         :param _builtins.str deployment_url: The URL of a resource.
         :param _builtins.str description: Metadata about this specific object.
         :param _builtins.str display_name: A filter to return only the resources that match the entire 'displayName' given.
@@ -6769,6 +6783,7 @@ class GetDeploymentsDeploymentCollectionItemResult(dict):
         :param _builtins.str id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the deployment being referenced.
         :param Sequence['GetDeploymentsDeploymentCollectionItemIngressIpArgs'] ingress_ips: List of ingress IP addresses from where the GoldenGate deployment connects to this connection's privateIp.  Customers may optionally set up ingress security rules to restrict traffic from these IP addresses.
         :param _builtins.bool is_auto_scaling_enabled: Indicates if auto scaling is enabled for the Deployment's CPU core count.
+        :param _builtins.bool is_byol_cpu_core_count_limit_enabled: Flag to allow to configure the 'Bring Your Own License' (BYOL) license type CPU limit. If enabled, the exact number of CPUs must be provided via byolCpuCoreCountLimit.
         :param _builtins.bool is_healthy: True if all of the aggregate resources are working correctly.
         :param _builtins.bool is_latest_version: Indicates if the resource is the the latest available version.
         :param _builtins.bool is_public: True if this object is publicly available.
@@ -6804,6 +6819,7 @@ class GetDeploymentsDeploymentCollectionItemResult(dict):
         """
         pulumi.set(__self__, "availability_domain", availability_domain)
         pulumi.set(__self__, "backup_schedules", backup_schedules)
+        pulumi.set(__self__, "byol_cpu_core_count_limit", byol_cpu_core_count_limit)
         pulumi.set(__self__, "category", category)
         pulumi.set(__self__, "compartment_id", compartment_id)
         pulumi.set(__self__, "cpu_core_count", cpu_core_count)
@@ -6822,6 +6838,7 @@ class GetDeploymentsDeploymentCollectionItemResult(dict):
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "ingress_ips", ingress_ips)
         pulumi.set(__self__, "is_auto_scaling_enabled", is_auto_scaling_enabled)
+        pulumi.set(__self__, "is_byol_cpu_core_count_limit_enabled", is_byol_cpu_core_count_limit_enabled)
         pulumi.set(__self__, "is_healthy", is_healthy)
         pulumi.set(__self__, "is_latest_version", is_latest_version)
         pulumi.set(__self__, "is_lock_override", is_lock_override)
@@ -6872,6 +6889,14 @@ class GetDeploymentsDeploymentCollectionItemResult(dict):
         """
         return pulumi.get(self, "backup_schedules")
 
+    @_builtins.property
+    @pulumi.getter(name="byolCpuCoreCountLimit")
+    def byol_cpu_core_count_limit(self) -> _builtins.int:
+        """
+        The maximum number of CPUs allowed with a 'Bring Your Own License' (BYOL) license type. Any CPU usage above this limit is considered as License Included and billed.
+        """
+        return pulumi.get(self, "byol_cpu_core_count_limit")
+
     @_builtins.property
     @pulumi.getter
     def category(self) -> _builtins.str:
@@ -6932,7 +6957,7 @@ class GetDeploymentsDeploymentCollectionItemResult(dict):
     @pulumi.getter(name="deploymentType")
     def deployment_type(self) -> _builtins.str:
         """
-        The type of deployment, which can be any one of the Allowed values.  NOTE: Use of the value 'OGG' is maintained for backward compatibility purposes.  Its use is discouraged in favor of 'DATABASE_ORACLE'.
+        A filter that returns only the resources matching the specified 'deploymentType'.
         """
         return pulumi.get(self, "deployment_type")
 
@@ -7016,6 +7041,14 @@ class GetDeploymentsDeploymentCollectionItemResult(dict):
         """
         return pulumi.get(self, "is_auto_scaling_enabled")
 
+    @_builtins.property
+    @pulumi.getter(name="isByolCpuCoreCountLimitEnabled")
+    def is_byol_cpu_core_count_limit_enabled(self) -> _builtins.bool:
+        """
+        Flag to allow to configure the 'Bring Your Own License' (BYOL) license type CPU limit. If enabled, the exact number of CPUs must be provided via byolCpuCoreCountLimit.
+        """
+        return pulumi.get(self, "is_byol_cpu_core_count_limit_enabled")
+
     @_builtins.property
     @pulumi.getter(name="isHealthy")
     def is_healthy(self) -> _builtins.bool:

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,