pulumi-oci 3.1.0a1750230541__py3-none-any.whl → 3.1.0a1751948424__py3-none-any.whl

pulumi_oci/mysql/_inputs.py

@@ -40,6 +40,8 @@ __all__ = [
     'MysqlBackupDbSystemSnapshotDataStorageArgsDict',
     'MysqlBackupDbSystemSnapshotDeletionPolicyArgs',
     'MysqlBackupDbSystemSnapshotDeletionPolicyArgsDict',
+    'MysqlBackupDbSystemSnapshotEncryptDataArgs',
+    'MysqlBackupDbSystemSnapshotEncryptDataArgsDict',
     'MysqlBackupDbSystemSnapshotEndpointArgs',
     'MysqlBackupDbSystemSnapshotEndpointArgsDict',
     'MysqlBackupDbSystemSnapshotMaintenanceArgs',
@@ -52,6 +54,8 @@ __all__ = [
     'MysqlBackupDbSystemSnapshotSecureConnectionArgsDict',
     'MysqlBackupDbSystemSnapshotSummaryArgs',
     'MysqlBackupDbSystemSnapshotSummaryArgsDict',
+    'MysqlBackupEncryptDataArgs',
+    'MysqlBackupEncryptDataArgsDict',
     'MysqlBackupSourceDetailsArgs',
     'MysqlBackupSourceDetailsArgsDict',
     'MysqlConfigurationInitVariablesArgs',
@@ -84,6 +88,8 @@ __all__ = [
     'MysqlDbSystemDataStorageArgsDict',
     'MysqlDbSystemDeletionPolicyArgs',
     'MysqlDbSystemDeletionPolicyArgsDict',
+    'MysqlDbSystemEncryptDataArgs',
+    'MysqlDbSystemEncryptDataArgsDict',
     'MysqlDbSystemEndpointArgs',
     'MysqlDbSystemEndpointArgsDict',
     'MysqlDbSystemHeatWaveClusterArgs',
@@ -100,6 +106,8 @@ __all__ = [
     'MysqlDbSystemSecureConnectionsArgsDict',
     'MysqlDbSystemSourceArgs',
     'MysqlDbSystemSourceArgsDict',
+    'ReplicaEncryptDataArgs',
+    'ReplicaEncryptDataArgsDict',
     'ReplicaReplicaOverridesArgs',
     'ReplicaReplicaOverridesArgsDict',
     'ReplicaSecureConnectionArgs',
@@ -803,6 +811,10 @@ if not MYPY:
         """
         (Updatable) A user-supplied display name for the backup.
         """
+        encrypt_datas: NotRequired[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotEncryptDataArgsDict']]]]
+        """
+        Encrypt data details.
+        """
         endpoints: NotRequired[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotEndpointArgsDict']]]]
         """
         The network endpoints available for this DB System.
@@ -894,6 +906,7 @@ class MysqlBackupDbSystemSnapshotArgs:
                  deletion_policies: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotDeletionPolicyArgs']]]] = None,
                  description: Optional[pulumi.Input[builtins.str]] = None,
                  display_name: Optional[pulumi.Input[builtins.str]] = None,
+                 encrypt_datas: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotEncryptDataArgs']]]] = None,
                  endpoints: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotEndpointArgs']]]] = None,
                  fault_domain: Optional[pulumi.Input[builtins.str]] = None,
                  freeform_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
@@ -926,6 +939,7 @@ class MysqlBackupDbSystemSnapshotArgs:
         :param pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotDeletionPolicyArgs']]] deletion_policies: The Deletion policy for the DB System.
         :param pulumi.Input[builtins.str] description: (Updatable) A user-supplied description for the backup.
         :param pulumi.Input[builtins.str] display_name: (Updatable) A user-supplied display name for the backup.
+        :param pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotEncryptDataArgs']]] encrypt_datas: Encrypt data details.
         :param pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotEndpointArgs']]] endpoints: The network endpoints available for this DB System.
         :param pulumi.Input[builtins.str] fault_domain: The name of the Fault Domain the DB System is located in.
         :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] freeform_tags: (Updatable) Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
@@ -971,6 +985,8 @@ class MysqlBackupDbSystemSnapshotArgs:
             pulumi.set(__self__, "description", description)
         if display_name is not None:
             pulumi.set(__self__, "display_name", display_name)
+        if encrypt_datas is not None:
+            pulumi.set(__self__, "encrypt_datas", encrypt_datas)
         if endpoints is not None:
             pulumi.set(__self__, "endpoints", endpoints)
         if fault_domain is not None:
@@ -1164,6 +1180,18 @@ class MysqlBackupDbSystemSnapshotArgs:
     def display_name(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "display_name", value)
 
+    @property
+    @pulumi.getter(name="encryptDatas")
+    def encrypt_datas(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotEncryptDataArgs']]]]:
+        """
+        Encrypt data details.
+        """
+        return pulumi.get(self, "encrypt_datas")
+
+    @encrypt_datas.setter
+    def encrypt_datas(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotEncryptDataArgs']]]]):
+        pulumi.set(self, "encrypt_datas", value)
+
     @property
     @pulumi.getter
     def endpoints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotEndpointArgs']]]]:
@@ -1407,6 +1435,10 @@ if not MYPY:
         """
         (Updatable) Number of days to retain this backup.
         """
+        soft_delete: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Updatable) Retains the backup to be deleted due to the retention policy in DELETE SCHEDULED state for 7 days before permanently deleting it.
+        """
         window_start_time: NotRequired[pulumi.Input[builtins.str]]
         """
         The start time of the maintenance window.
@@ -1423,6 +1455,7 @@ class MysqlBackupDbSystemSnapshotBackupPolicyArgs:
                  is_enabled: Optional[pulumi.Input[builtins.bool]] = None,
                  pitr_policies: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotBackupPolicyPitrPolicyArgs']]]] = None,
                  retention_in_days: Optional[pulumi.Input[builtins.int]] = None,
+                 soft_delete: Optional[pulumi.Input[builtins.str]] = None,
                  window_start_time: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotBackupPolicyCopyPolicyArgs']]] copy_policies: List of policies of a DB system to schedule cross-region DB system backup copy.
@@ -1431,6 +1464,7 @@ class MysqlBackupDbSystemSnapshotBackupPolicyArgs:
         :param pulumi.Input[builtins.bool] is_enabled: Specifies if the DB System read endpoint is enabled or not.
         :param pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotBackupPolicyPitrPolicyArgs']]] pitr_policies: The PITR policy for the DB System.
         :param pulumi.Input[builtins.int] retention_in_days: (Updatable) Number of days to retain this backup.
+        :param pulumi.Input[builtins.str] soft_delete: (Updatable) Retains the backup to be deleted due to the retention policy in DELETE SCHEDULED state for 7 days before permanently deleting it.
         :param pulumi.Input[builtins.str] window_start_time: The start time of the maintenance window.
         """
         if copy_policies is not None:
@@ -1445,6 +1479,8 @@ class MysqlBackupDbSystemSnapshotBackupPolicyArgs:
             pulumi.set(__self__, "pitr_policies", pitr_policies)
         if retention_in_days is not None:
             pulumi.set(__self__, "retention_in_days", retention_in_days)
+        if soft_delete is not None:
+            pulumi.set(__self__, "soft_delete", soft_delete)
         if window_start_time is not None:
             pulumi.set(__self__, "window_start_time", window_start_time)
 
@@ -1520,6 +1556,18 @@ class MysqlBackupDbSystemSnapshotBackupPolicyArgs:
     def retention_in_days(self, value: Optional[pulumi.Input[builtins.int]]):
         pulumi.set(self, "retention_in_days", value)
 
+    @property
+    @pulumi.getter(name="softDelete")
+    def soft_delete(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Updatable) Retains the backup to be deleted due to the retention policy in DELETE SCHEDULED state for 7 days before permanently deleting it.
+        """
+        return pulumi.get(self, "soft_delete")
+
+    @soft_delete.setter
+    def soft_delete(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "soft_delete", value)
+
     @property
     @pulumi.getter(name="windowStartTime")
     def window_start_time(self) -> Optional[pulumi.Input[builtins.str]]:
@@ -1801,6 +1849,58 @@ class MysqlBackupDbSystemSnapshotDeletionPolicyArgs:
         pulumi.set(self, "is_delete_protected", value)
 
 
+if not MYPY:
+    class MysqlBackupDbSystemSnapshotEncryptDataArgsDict(TypedDict):
+        key_generation_type: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Select whether to use Oracle-managed key (SYSTEM) or your own key (BYOK).
+        """
+        key_id: NotRequired[pulumi.Input[builtins.str]]
+        """
+        The OCID of the key to use.
+        """
+elif False:
+    MysqlBackupDbSystemSnapshotEncryptDataArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class MysqlBackupDbSystemSnapshotEncryptDataArgs:
+    def __init__(__self__, *,
+                 key_generation_type: Optional[pulumi.Input[builtins.str]] = None,
+                 key_id: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        :param pulumi.Input[builtins.str] key_generation_type: Select whether to use Oracle-managed key (SYSTEM) or your own key (BYOK).
+        :param pulumi.Input[builtins.str] key_id: The OCID of the key to use.
+        """
+        if key_generation_type is not None:
+            pulumi.set(__self__, "key_generation_type", key_generation_type)
+        if key_id is not None:
+            pulumi.set(__self__, "key_id", key_id)
+
+    @property
+    @pulumi.getter(name="keyGenerationType")
+    def key_generation_type(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Select whether to use Oracle-managed key (SYSTEM) or your own key (BYOK).
+        """
+        return pulumi.get(self, "key_generation_type")
+
+    @key_generation_type.setter
+    def key_generation_type(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "key_generation_type", value)
+
+    @property
+    @pulumi.getter(name="keyId")
+    def key_id(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        The OCID of the key to use.
+        """
+        return pulumi.get(self, "key_id")
+
+    @key_id.setter
+    def key_id(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "key_id", value)
+
+
 if not MYPY:
     class MysqlBackupDbSystemSnapshotEndpointArgsDict(TypedDict):
         hostname: NotRequired[pulumi.Input[builtins.str]]
@@ -2293,6 +2393,57 @@ class MysqlBackupDbSystemSnapshotSummaryArgs:
         pulumi.set(self, "region", value)
 
 
+if not MYPY:
+    class MysqlBackupEncryptDataArgsDict(TypedDict):
+        key_generation_type: pulumi.Input[builtins.str]
+        """
+        Select whether to use Oracle-managed key (SYSTEM) or your own key (BYOK).
+        """
+        key_id: NotRequired[pulumi.Input[builtins.str]]
+        """
+        The OCID of the key to use.
+        """
+elif False:
+    MysqlBackupEncryptDataArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class MysqlBackupEncryptDataArgs:
+    def __init__(__self__, *,
+                 key_generation_type: pulumi.Input[builtins.str],
+                 key_id: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        :param pulumi.Input[builtins.str] key_generation_type: Select whether to use Oracle-managed key (SYSTEM) or your own key (BYOK).
+        :param pulumi.Input[builtins.str] key_id: The OCID of the key to use.
+        """
+        pulumi.set(__self__, "key_generation_type", key_generation_type)
+        if key_id is not None:
+            pulumi.set(__self__, "key_id", key_id)
+
+    @property
+    @pulumi.getter(name="keyGenerationType")
+    def key_generation_type(self) -> pulumi.Input[builtins.str]:
+        """
+        Select whether to use Oracle-managed key (SYSTEM) or your own key (BYOK).
+        """
+        return pulumi.get(self, "key_generation_type")
+
+    @key_generation_type.setter
+    def key_generation_type(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "key_generation_type", value)
+
+    @property
+    @pulumi.getter(name="keyId")
+    def key_id(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        The OCID of the key to use.
+        """
+        return pulumi.get(self, "key_id")
+
+    @key_id.setter
+    def key_id(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "key_id", value)
+
+
 if not MYPY:
     class MysqlBackupSourceDetailsArgsDict(TypedDict):
         backup_id: pulumi.Input[builtins.str]
@@ -5396,6 +5547,10 @@ if not MYPY:
         """
         (Updatable) Number of days to retain an automatic backup.
         """
+        soft_delete: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Updatable) Retains the backup to be deleted due to the retention policy in DELETE SCHEDULED state for 7 days before permanently deleting it.
+        """
         window_start_time: NotRequired[pulumi.Input[builtins.str]]
         """
         (Updatable) The start of a 30-minute window of time in which daily, automated backups occur.
@@ -5416,6 +5571,7 @@ class MysqlDbSystemBackupPolicyArgs:
                  is_enabled: Optional[pulumi.Input[builtins.bool]] = None,
                  pitr_policy: Optional[pulumi.Input['MysqlDbSystemBackupPolicyPitrPolicyArgs']] = None,
                  retention_in_days: Optional[pulumi.Input[builtins.int]] = None,
+                 soft_delete: Optional[pulumi.Input[builtins.str]] = None,
                  window_start_time: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[Sequence[pulumi.Input['MysqlDbSystemBackupPolicyCopyPolicyArgs']]] copy_policies: (Updatable) List of policies of a DB system to schedule cross-region DB system backup copy.
@@ -5436,6 +5592,7 @@ class MysqlDbSystemBackupPolicyArgs:
         :param pulumi.Input[builtins.bool] is_enabled: (Updatable) Specifies if automatic backups are enabled.
         :param pulumi.Input['MysqlDbSystemBackupPolicyPitrPolicyArgs'] pitr_policy: (Updatable) The PITR policy for the DB System.
         :param pulumi.Input[builtins.int] retention_in_days: (Updatable) Number of days to retain an automatic backup.
+        :param pulumi.Input[builtins.str] soft_delete: (Updatable) Retains the backup to be deleted due to the retention policy in DELETE SCHEDULED state for 7 days before permanently deleting it.
         :param pulumi.Input[builtins.str] window_start_time: (Updatable) The start of a 30-minute window of time in which daily, automated backups occur.
                
                This should be in the format of the "Time" portion of an RFC3339-formatted timestamp. Any second or sub-second time data will be truncated to zero.
@@ -5454,6 +5611,8 @@ class MysqlDbSystemBackupPolicyArgs:
             pulumi.set(__self__, "pitr_policy", pitr_policy)
         if retention_in_days is not None:
             pulumi.set(__self__, "retention_in_days", retention_in_days)
+        if soft_delete is not None:
+            pulumi.set(__self__, "soft_delete", soft_delete)
         if window_start_time is not None:
             pulumi.set(__self__, "window_start_time", window_start_time)
 
@@ -5541,6 +5700,18 @@ class MysqlDbSystemBackupPolicyArgs:
     def retention_in_days(self, value: Optional[pulumi.Input[builtins.int]]):
         pulumi.set(self, "retention_in_days", value)
 
+    @property
+    @pulumi.getter(name="softDelete")
+    def soft_delete(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Updatable) Retains the backup to be deleted due to the retention policy in DELETE SCHEDULED state for 7 days before permanently deleting it.
+        """
+        return pulumi.get(self, "soft_delete")
+
+    @soft_delete.setter
+    def soft_delete(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "soft_delete", value)
+
     @property
     @pulumi.getter(name="windowStartTime")
     def window_start_time(self) -> Optional[pulumi.Input[builtins.str]]:
@@ -6716,6 +6887,57 @@ class MysqlDbSystemDeletionPolicyArgs:
         pulumi.set(self, "is_delete_protected", value)
 
 
+if not MYPY:
+    class MysqlDbSystemEncryptDataArgsDict(TypedDict):
+        key_generation_type: pulumi.Input[builtins.str]
+        """
+        (Updatable) Select whether to use Oracle-managed key (SYSTEM) or your own key (BYOK).
+        """
+        key_id: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Updatable) The OCID of the key to use.
+        """
+elif False:
+    MysqlDbSystemEncryptDataArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class MysqlDbSystemEncryptDataArgs:
+    def __init__(__self__, *,
+                 key_generation_type: pulumi.Input[builtins.str],
+                 key_id: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        :param pulumi.Input[builtins.str] key_generation_type: (Updatable) Select whether to use Oracle-managed key (SYSTEM) or your own key (BYOK).
+        :param pulumi.Input[builtins.str] key_id: (Updatable) The OCID of the key to use.
+        """
+        pulumi.set(__self__, "key_generation_type", key_generation_type)
+        if key_id is not None:
+            pulumi.set(__self__, "key_id", key_id)
+
+    @property
+    @pulumi.getter(name="keyGenerationType")
+    def key_generation_type(self) -> pulumi.Input[builtins.str]:
+        """
+        (Updatable) Select whether to use Oracle-managed key (SYSTEM) or your own key (BYOK).
+        """
+        return pulumi.get(self, "key_generation_type")
+
+    @key_generation_type.setter
+    def key_generation_type(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "key_generation_type", value)
+
+    @property
+    @pulumi.getter(name="keyId")
+    def key_id(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Updatable) The OCID of the key to use.
+        """
+        return pulumi.get(self, "key_id")
+
+    @key_id.setter
+    def key_id(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "key_id", value)
+
+
 if not MYPY:
     class MysqlDbSystemEndpointArgsDict(TypedDict):
         hostname: NotRequired[pulumi.Input[builtins.str]]
@@ -7467,6 +7689,58 @@ class MysqlDbSystemSourceArgs:
         pulumi.set(self, "source_url", value)
 
 
+if not MYPY:
+    class ReplicaEncryptDataArgsDict(TypedDict):
+        key_generation_type: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Select whether to use Oracle-managed key (SYSTEM) or your own key (BYOK).
+        """
+        key_id: NotRequired[pulumi.Input[builtins.str]]
+        """
+        The OCID of the key to use.
+        """
+elif False:
+    ReplicaEncryptDataArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ReplicaEncryptDataArgs:
+    def __init__(__self__, *,
+                 key_generation_type: Optional[pulumi.Input[builtins.str]] = None,
+                 key_id: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        :param pulumi.Input[builtins.str] key_generation_type: Select whether to use Oracle-managed key (SYSTEM) or your own key (BYOK).
+        :param pulumi.Input[builtins.str] key_id: The OCID of the key to use.
+        """
+        if key_generation_type is not None:
+            pulumi.set(__self__, "key_generation_type", key_generation_type)
+        if key_id is not None:
+            pulumi.set(__self__, "key_id", key_id)
+
+    @property
+    @pulumi.getter(name="keyGenerationType")
+    def key_generation_type(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Select whether to use Oracle-managed key (SYSTEM) or your own key (BYOK).
+        """
+        return pulumi.get(self, "key_generation_type")
+
+    @key_generation_type.setter
+    def key_generation_type(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "key_generation_type", value)
+
+    @property
+    @pulumi.getter(name="keyId")
+    def key_id(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        The OCID of the key to use.
+        """
+        return pulumi.get(self, "key_id")
+
+    @key_id.setter
+    def key_id(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "key_id", value)
+
+
 if not MYPY:
     class ReplicaReplicaOverridesArgsDict(TypedDict):
         configuration_id: NotRequired[pulumi.Input[builtins.str]]

pulumi_oci/mysql/get_mysql_backup.py

@@ -28,7 +28,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, 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, 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, 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):
         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)
@@ -65,6 +65,9 @@ class GetMysqlBackupResult:
         if display_name and not isinstance(display_name, str):
             raise TypeError("Expected argument 'display_name' to be a str")
         pulumi.set(__self__, "display_name", display_name)
+        if encrypt_datas and not isinstance(encrypt_datas, list):
+            raise TypeError("Expected argument 'encrypt_datas' to be a list")
+        pulumi.set(__self__, "encrypt_datas", encrypt_datas)
         if freeform_tags and not isinstance(freeform_tags, dict):
             raise TypeError("Expected argument 'freeform_tags' to be a dict")
         pulumi.set(__self__, "freeform_tags", freeform_tags)
@@ -89,6 +92,9 @@ class GetMysqlBackupResult:
         if shape_name and not isinstance(shape_name, str):
             raise TypeError("Expected argument 'shape_name' to be a str")
         pulumi.set(__self__, "shape_name", shape_name)
+        if soft_delete and not isinstance(soft_delete, str):
+            raise TypeError("Expected argument 'soft_delete' to be a str")
+        pulumi.set(__self__, "soft_delete", soft_delete)
         if source_details and not isinstance(source_details, list):
             raise TypeError("Expected argument 'source_details' to be a list")
         pulumi.set(__self__, "source_details", source_details)
@@ -198,6 +204,14 @@ class GetMysqlBackupResult:
         """
         return pulumi.get(self, "display_name")
 
+    @property
+    @pulumi.getter(name="encryptDatas")
+    def encrypt_datas(self) -> Sequence['outputs.GetMysqlBackupEncryptDataResult']:
+        """
+        Encrypt data details.
+        """
+        return pulumi.get(self, "encrypt_datas")
+
     @property
     @pulumi.getter(name="freeformTags")
     def freeform_tags(self) -> Mapping[str, builtins.str]:
@@ -262,6 +276,14 @@ class GetMysqlBackupResult:
         """
         return pulumi.get(self, "shape_name")
 
+    @property
+    @pulumi.getter(name="softDelete")
+    def soft_delete(self) -> builtins.str:
+        """
+        Retains the backup to be deleted due to the retention policy in DELETE SCHEDULED state for 7 days before permanently deleting it.
+        """
+        return pulumi.get(self, "soft_delete")
+
     @property
     @pulumi.getter(name="sourceDetails")
     def source_details(self) -> Sequence['outputs.GetMysqlBackupSourceDetailResult']:
@@ -326,6 +348,7 @@ class AwaitableGetMysqlBackupResult(GetMysqlBackupResult):
             defined_tags=self.defined_tags,
             description=self.description,
             display_name=self.display_name,
+            encrypt_datas=self.encrypt_datas,
             freeform_tags=self.freeform_tags,
             id=self.id,
             immediate_source_backup_id=self.immediate_source_backup_id,
@@ -334,6 +357,7 @@ class AwaitableGetMysqlBackupResult(GetMysqlBackupResult):
             original_source_backup_id=self.original_source_backup_id,
             retention_in_days=self.retention_in_days,
             shape_name=self.shape_name,
+            soft_delete=self.soft_delete,
             source_details=self.source_details,
             state=self.state,
             system_tags=self.system_tags,
@@ -379,6 +403,7 @@ def get_mysql_backup(backup_id: Optional[builtins.str] = None,
         defined_tags=pulumi.get(__ret__, 'defined_tags'),
         description=pulumi.get(__ret__, 'description'),
         display_name=pulumi.get(__ret__, 'display_name'),
+        encrypt_datas=pulumi.get(__ret__, 'encrypt_datas'),
         freeform_tags=pulumi.get(__ret__, 'freeform_tags'),
         id=pulumi.get(__ret__, 'id'),
         immediate_source_backup_id=pulumi.get(__ret__, 'immediate_source_backup_id'),
@@ -387,6 +412,7 @@ def get_mysql_backup(backup_id: Optional[builtins.str] = None,
         original_source_backup_id=pulumi.get(__ret__, 'original_source_backup_id'),
         retention_in_days=pulumi.get(__ret__, 'retention_in_days'),
         shape_name=pulumi.get(__ret__, 'shape_name'),
+        soft_delete=pulumi.get(__ret__, 'soft_delete'),
         source_details=pulumi.get(__ret__, 'source_details'),
         state=pulumi.get(__ret__, 'state'),
         system_tags=pulumi.get(__ret__, 'system_tags'),
@@ -429,6 +455,7 @@ def get_mysql_backup_output(backup_id: Optional[pulumi.Input[builtins.str]] = No
         defined_tags=pulumi.get(__response__, 'defined_tags'),
         description=pulumi.get(__response__, 'description'),
         display_name=pulumi.get(__response__, 'display_name'),
+        encrypt_datas=pulumi.get(__response__, 'encrypt_datas'),
         freeform_tags=pulumi.get(__response__, 'freeform_tags'),
         id=pulumi.get(__response__, 'id'),
         immediate_source_backup_id=pulumi.get(__response__, 'immediate_source_backup_id'),
@@ -437,6 +464,7 @@ def get_mysql_backup_output(backup_id: Optional[pulumi.Input[builtins.str]] = No
         original_source_backup_id=pulumi.get(__response__, 'original_source_backup_id'),
         retention_in_days=pulumi.get(__response__, 'retention_in_days'),
         shape_name=pulumi.get(__response__, 'shape_name'),
+        soft_delete=pulumi.get(__response__, 'soft_delete'),
         source_details=pulumi.get(__response__, 'source_details'),
         state=pulumi.get(__response__, 'state'),
         system_tags=pulumi.get(__response__, 'system_tags'),

pulumi_oci/mysql/get_mysql_backups.py

@@ -29,7 +29,7 @@ class GetMysqlBackupsResult:
     """
     A collection of values returned by getMysqlBackups.
     """
-    def __init__(__self__, backup_id=None, backups=None, compartment_id=None, creation_type=None, db_system_id=None, display_name=None, filters=None, id=None, state=None):
+    def __init__(__self__, backup_id=None, backups=None, compartment_id=None, creation_type=None, db_system_id=None, display_name=None, filters=None, id=None, soft_delete=None, state=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)
@@ -54,6 +54,9 @@ class GetMysqlBackupsResult:
         if id and not isinstance(id, str):
             raise TypeError("Expected argument 'id' to be a str")
         pulumi.set(__self__, "id", id)
+        if soft_delete and not isinstance(soft_delete, str):
+            raise TypeError("Expected argument 'soft_delete' to be a str")
+        pulumi.set(__self__, "soft_delete", soft_delete)
         if state and not isinstance(state, str):
             raise TypeError("Expected argument 'state' to be a str")
         pulumi.set(__self__, "state", state)
@@ -116,6 +119,14 @@ class GetMysqlBackupsResult:
         """
         return pulumi.get(self, "id")
 
+    @property
+    @pulumi.getter(name="softDelete")
+    def soft_delete(self) -> Optional[builtins.str]:
+        """
+        Retains the backup to be deleted due to the retention policy in DELETE SCHEDULED state for 7 days before permanently deleting it.
+        """
+        return pulumi.get(self, "soft_delete")
+
     @property
     @pulumi.getter
     def state(self) -> Optional[builtins.str]:
@@ -139,6 +150,7 @@ class AwaitableGetMysqlBackupsResult(GetMysqlBackupsResult):
             display_name=self.display_name,
             filters=self.filters,
             id=self.id,
+            soft_delete=self.soft_delete,
             state=self.state)
 
 
@@ -148,6 +160,7 @@ def get_mysql_backups(backup_id: Optional[builtins.str] = None,
                       db_system_id: Optional[builtins.str] = None,
                       display_name: Optional[builtins.str] = None,
                       filters: Optional[Sequence[Union['GetMysqlBackupsFilterArgs', 'GetMysqlBackupsFilterArgsDict']]] = None,
+                      soft_delete: Optional[builtins.str] = None,
                       state: Optional[builtins.str] = None,
                       opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetMysqlBackupsResult:
     """
@@ -166,6 +179,7 @@ def get_mysql_backups(backup_id: Optional[builtins.str] = None,
         creation_type=mysql_backup_creation_type,
         db_system_id=test_db_system["id"],
         display_name=mysql_backup_display_name,
+        soft_delete=mysql_backup_soft_delete,
         state=mysql_backup_state)
     ```
 
@@ -175,6 +189,7 @@ def get_mysql_backups(backup_id: Optional[builtins.str] = None,
     :param builtins.str creation_type: Backup creationType
     :param builtins.str db_system_id: The DB System [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
     :param builtins.str display_name: A filter to return only the resource matching the given display name exactly.
+    :param builtins.str soft_delete: Backup Soft Delete
     :param builtins.str state: Backup Lifecycle State
     """
     __args__ = dict()
@@ -184,6 +199,7 @@ def get_mysql_backups(backup_id: Optional[builtins.str] = None,
     __args__['dbSystemId'] = db_system_id
     __args__['displayName'] = display_name
     __args__['filters'] = filters
+    __args__['softDelete'] = soft_delete
     __args__['state'] = state
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke('oci:Mysql/getMysqlBackups:getMysqlBackups', __args__, opts=opts, typ=GetMysqlBackupsResult).value
@@ -197,6 +213,7 @@ def get_mysql_backups(backup_id: Optional[builtins.str] = None,
         display_name=pulumi.get(__ret__, 'display_name'),
         filters=pulumi.get(__ret__, 'filters'),
         id=pulumi.get(__ret__, 'id'),
+        soft_delete=pulumi.get(__ret__, 'soft_delete'),
         state=pulumi.get(__ret__, 'state'))
 def get_mysql_backups_output(backup_id: Optional[pulumi.Input[Optional[builtins.str]]] = None,
                              compartment_id: Optional[pulumi.Input[builtins.str]] = None,
@@ -204,6 +221,7 @@ def get_mysql_backups_output(backup_id: Optional[pulumi.Input[Optional[builtins.
                              db_system_id: Optional[pulumi.Input[Optional[builtins.str]]] = None,
                              display_name: Optional[pulumi.Input[Optional[builtins.str]]] = None,
                              filters: Optional[pulumi.Input[Optional[Sequence[Union['GetMysqlBackupsFilterArgs', 'GetMysqlBackupsFilterArgsDict']]]]] = None,
+                             soft_delete: Optional[pulumi.Input[Optional[builtins.str]]] = None,
                              state: Optional[pulumi.Input[Optional[builtins.str]]] = None,
                              opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetMysqlBackupsResult]:
     """
@@ -222,6 +240,7 @@ def get_mysql_backups_output(backup_id: Optional[pulumi.Input[Optional[builtins.
         creation_type=mysql_backup_creation_type,
         db_system_id=test_db_system["id"],
         display_name=mysql_backup_display_name,
+        soft_delete=mysql_backup_soft_delete,
         state=mysql_backup_state)
     ```
 
@@ -231,6 +250,7 @@ def get_mysql_backups_output(backup_id: Optional[pulumi.Input[Optional[builtins.
     :param builtins.str creation_type: Backup creationType
     :param builtins.str db_system_id: The DB System [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
     :param builtins.str display_name: A filter to return only the resource matching the given display name exactly.
+    :param builtins.str soft_delete: Backup Soft Delete
     :param builtins.str state: Backup Lifecycle State
     """
     __args__ = dict()
@@ -240,6 +260,7 @@ def get_mysql_backups_output(backup_id: Optional[pulumi.Input[Optional[builtins.
     __args__['dbSystemId'] = db_system_id
     __args__['displayName'] = display_name
     __args__['filters'] = filters
+    __args__['softDelete'] = soft_delete
     __args__['state'] = state
     opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('oci:Mysql/getMysqlBackups:getMysqlBackups', __args__, opts=opts, typ=GetMysqlBackupsResult)
@@ -252,4 +273,5 @@ def get_mysql_backups_output(backup_id: Optional[pulumi.Input[Optional[builtins.
         display_name=pulumi.get(__response__, 'display_name'),
         filters=pulumi.get(__response__, 'filters'),
         id=pulumi.get(__response__, 'id'),
+        soft_delete=pulumi.get(__response__, 'soft_delete'),
         state=pulumi.get(__response__, 'state')))