pulumi-oci 2.7.0a1723624751__py3-none-any.whl → 2.8.0__py3-none-any.whl

pulumi_oci/mysql/outputs.py

@@ -20,6 +20,7 @@ __all__ = [
     'MysqlBackupDbSystemSnapshot',
     'MysqlBackupDbSystemSnapshotBackupPolicy',
     'MysqlBackupDbSystemSnapshotBackupPolicyPitrPolicy',
+    'MysqlBackupDbSystemSnapshotDataStorage',
     'MysqlBackupDbSystemSnapshotDeletionPolicy',
     'MysqlBackupDbSystemSnapshotEndpoint',
     'MysqlBackupDbSystemSnapshotMaintenance',
@@ -37,6 +38,7 @@ __all__ = [
     'MysqlDbSystemChannelTarget',
     'MysqlDbSystemChannelTargetFilter',
     'MysqlDbSystemCurrentPlacement',
+    'MysqlDbSystemDataStorage',
     'MysqlDbSystemDeletionPolicy',
     'MysqlDbSystemEndpoint',
     'MysqlDbSystemHeatWaveCluster',
@@ -62,6 +64,7 @@ __all__ = [
     'GetMysqlBackupDbSystemSnapshotResult',
     'GetMysqlBackupDbSystemSnapshotBackupPolicyResult',
     'GetMysqlBackupDbSystemSnapshotBackupPolicyPitrPolicyResult',
+    'GetMysqlBackupDbSystemSnapshotDataStorageResult',
     'GetMysqlBackupDbSystemSnapshotDeletionPolicyResult',
     'GetMysqlBackupDbSystemSnapshotEndpointResult',
     'GetMysqlBackupDbSystemSnapshotMaintenanceResult',
@@ -72,6 +75,7 @@ __all__ = [
     'GetMysqlBackupsBackupDbSystemSnapshotResult',
     'GetMysqlBackupsBackupDbSystemSnapshotBackupPolicyResult',
     'GetMysqlBackupsBackupDbSystemSnapshotBackupPolicyPitrPolicyResult',
+    'GetMysqlBackupsBackupDbSystemSnapshotDataStorageResult',
     'GetMysqlBackupsBackupDbSystemSnapshotDeletionPolicyResult',
     'GetMysqlBackupsBackupDbSystemSnapshotEndpointResult',
     'GetMysqlBackupsBackupDbSystemSnapshotMaintenanceResult',
@@ -94,6 +98,7 @@ __all__ = [
     'GetMysqlDbSystemChannelTargetResult',
     'GetMysqlDbSystemChannelTargetFilterResult',
     'GetMysqlDbSystemCurrentPlacementResult',
+    'GetMysqlDbSystemDataStorageResult',
     'GetMysqlDbSystemDeletionPolicyResult',
     'GetMysqlDbSystemEndpointResult',
     'GetMysqlDbSystemHeatWaveClusterResult',
@@ -111,6 +116,7 @@ __all__ = [
     'GetMysqlDbSystemsDbSystemChannelTargetResult',
     'GetMysqlDbSystemsDbSystemChannelTargetFilterResult',
     'GetMysqlDbSystemsDbSystemCurrentPlacementResult',
+    'GetMysqlDbSystemsDbSystemDataStorageResult',
     'GetMysqlDbSystemsDbSystemDeletionPolicyResult',
     'GetMysqlDbSystemsDbSystemEndpointResult',
     'GetMysqlDbSystemsDbSystemHeatWaveClusterResult',
@@ -630,6 +636,8 @@ class MysqlBackupDbSystemSnapshot(dict):
             suggest = "crash_recovery"
         elif key == "dataStorageSizeInGb":
             suggest = "data_storage_size_in_gb"
+        elif key == "dataStorages":
+            suggest = "data_storages"
         elif key == "databaseManagement":
             suggest = "database_management"
         elif key == "definedTags":
@@ -678,14 +686,15 @@ class MysqlBackupDbSystemSnapshot(dict):
                  configuration_id: Optional[str] = None,
                  crash_recovery: Optional[str] = None,
                  data_storage_size_in_gb: Optional[int] = None,
+                 data_storages: Optional[Sequence['outputs.MysqlBackupDbSystemSnapshotDataStorage']] = None,
                  database_management: Optional[str] = None,
-                 defined_tags: Optional[Mapping[str, Any]] = None,
+                 defined_tags: Optional[Mapping[str, str]] = None,
                  deletion_policies: Optional[Sequence['outputs.MysqlBackupDbSystemSnapshotDeletionPolicy']] = None,
                  description: Optional[str] = None,
                  display_name: Optional[str] = None,
                  endpoints: Optional[Sequence['outputs.MysqlBackupDbSystemSnapshotEndpoint']] = None,
                  fault_domain: Optional[str] = None,
-                 freeform_tags: Optional[Mapping[str, Any]] = None,
+                 freeform_tags: Optional[Mapping[str, str]] = None,
                  hostname_label: Optional[str] = None,
                  id: Optional[str] = None,
                  ip_address: Optional[str] = None,
@@ -705,15 +714,16 @@ class MysqlBackupDbSystemSnapshot(dict):
         :param str compartment_id: (Updatable) The OCID of the compartment the backup exists in.
         :param str configuration_id: The OCID of the Configuration to be used for Instances in this DB System.
         :param str crash_recovery: Whether to run the DB System with InnoDB Redo Logs and the Double Write Buffer enabled or disabled, and whether to enable or disable syncing of the Binary Logs.
-        :param int data_storage_size_in_gb: Initial size of the data volume in GiBs that will be created and attached.
+        :param int data_storage_size_in_gb: DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
+        :param Sequence['MysqlBackupDbSystemSnapshotDataStorageArgs'] data_storages: Data Storage information.
         :param str database_management: Whether to enable monitoring via the Database Management service.
-        :param Mapping[str, Any] defined_tags: (Updatable) Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
+        :param Mapping[str, str] defined_tags: (Updatable) Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         :param Sequence['MysqlBackupDbSystemSnapshotDeletionPolicyArgs'] deletion_policies: The Deletion policy for the DB System.
         :param str description: (Updatable) A user-supplied description for the backup.
         :param str display_name: (Updatable) A user-supplied display name for the backup.
         :param Sequence['MysqlBackupDbSystemSnapshotEndpointArgs'] endpoints: The network endpoints available for this DB System.
         :param str fault_domain: The name of the Fault Domain the DB System is located in.
-        :param Mapping[str, Any] 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"}`
+        :param Mapping[str, 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"}`
         :param str hostname_label: The hostname for the primary endpoint of the DB System. Used for DNS. The value is the hostname portion of the primary private IP's fully qualified domain name (FQDN) (for example, "dbsystem-1" in FQDN "dbsystem-1.subnet123.vcn1.oraclevcn.com"). Must be unique across all VNICs in the subnet and comply with RFC 952 and RFC 1123.
         :param str id: OCID of the backup itself
         :param str ip_address: The IP address the DB System is configured to listen on. A private IP address of the primary endpoint of the DB System. Must be an available IP address within the subnet's CIDR. This will be a "dotted-quad" style IPv4 address.
@@ -741,6 +751,8 @@ class MysqlBackupDbSystemSnapshot(dict):
             pulumi.set(__self__, "crash_recovery", crash_recovery)
         if data_storage_size_in_gb is not None:
             pulumi.set(__self__, "data_storage_size_in_gb", data_storage_size_in_gb)
+        if data_storages is not None:
+            pulumi.set(__self__, "data_storages", data_storages)
         if database_management is not None:
             pulumi.set(__self__, "database_management", database_management)
         if defined_tags is not None:
@@ -834,10 +846,18 @@ class MysqlBackupDbSystemSnapshot(dict):
     @pulumi.getter(name="dataStorageSizeInGb")
     def data_storage_size_in_gb(self) -> Optional[int]:
         """
-        Initial size of the data volume in GiBs that will be created and attached.
+        DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
         """
         return pulumi.get(self, "data_storage_size_in_gb")
 
+    @property
+    @pulumi.getter(name="dataStorages")
+    def data_storages(self) -> Optional[Sequence['outputs.MysqlBackupDbSystemSnapshotDataStorage']]:
+        """
+        Data Storage information.
+        """
+        return pulumi.get(self, "data_storages")
+
     @property
     @pulumi.getter(name="databaseManagement")
     def database_management(self) -> Optional[str]:
@@ -848,7 +868,7 @@ class MysqlBackupDbSystemSnapshot(dict):
 
     @property
     @pulumi.getter(name="definedTags")
-    def defined_tags(self) -> Optional[Mapping[str, Any]]:
+    def defined_tags(self) -> Optional[Mapping[str, str]]:
         """
         (Updatable) Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         """
@@ -896,7 +916,7 @@ class MysqlBackupDbSystemSnapshot(dict):
 
     @property
     @pulumi.getter(name="freeformTags")
-    def freeform_tags(self) -> Optional[Mapping[str, Any]]:
+    def freeform_tags(self) -> Optional[Mapping[str, str]]:
         """
         (Updatable) Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         """
@@ -1029,15 +1049,15 @@ class MysqlBackupDbSystemSnapshotBackupPolicy(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 defined_tags: Optional[Mapping[str, Any]] = None,
-                 freeform_tags: Optional[Mapping[str, Any]] = None,
+                 defined_tags: Optional[Mapping[str, str]] = None,
+                 freeform_tags: Optional[Mapping[str, str]] = None,
                  is_enabled: Optional[bool] = None,
                  pitr_policies: Optional[Sequence['outputs.MysqlBackupDbSystemSnapshotBackupPolicyPitrPolicy']] = None,
                  retention_in_days: Optional[int] = None,
                  window_start_time: Optional[str] = None):
         """
-        :param Mapping[str, Any] defined_tags: (Updatable) Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
-        :param Mapping[str, Any] 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"}`
+        :param Mapping[str, str] defined_tags: (Updatable) Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
+        :param Mapping[str, 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"}`
         :param bool is_enabled: Specifies if PITR is enabled or disabled.
         :param Sequence['MysqlBackupDbSystemSnapshotBackupPolicyPitrPolicyArgs'] pitr_policies: The PITR policy for the DB System.
         :param int retention_in_days: (Updatable) Number of days to retain this backup.
@@ -1058,7 +1078,7 @@ class MysqlBackupDbSystemSnapshotBackupPolicy(dict):
 
     @property
     @pulumi.getter(name="definedTags")
-    def defined_tags(self) -> Optional[Mapping[str, Any]]:
+    def defined_tags(self) -> Optional[Mapping[str, str]]:
         """
         (Updatable) Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         """
@@ -1066,7 +1086,7 @@ class MysqlBackupDbSystemSnapshotBackupPolicy(dict):
 
     @property
     @pulumi.getter(name="freeformTags")
-    def freeform_tags(self) -> Optional[Mapping[str, Any]]:
+    def freeform_tags(self) -> Optional[Mapping[str, str]]:
         """
         (Updatable) Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         """
@@ -1141,6 +1161,98 @@ class MysqlBackupDbSystemSnapshotBackupPolicyPitrPolicy(dict):
         return pulumi.get(self, "is_enabled")
 
 
+@pulumi.output_type
+class MysqlBackupDbSystemSnapshotDataStorage(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "allocatedStorageSizeInGbs":
+            suggest = "allocated_storage_size_in_gbs"
+        elif key == "dataStorageSizeInGb":
+            suggest = "data_storage_size_in_gb"
+        elif key == "dataStorageSizeLimitInGbs":
+            suggest = "data_storage_size_limit_in_gbs"
+        elif key == "isAutoExpandStorageEnabled":
+            suggest = "is_auto_expand_storage_enabled"
+        elif key == "maxStorageSizeInGbs":
+            suggest = "max_storage_size_in_gbs"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in MysqlBackupDbSystemSnapshotDataStorage. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        MysqlBackupDbSystemSnapshotDataStorage.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        MysqlBackupDbSystemSnapshotDataStorage.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 allocated_storage_size_in_gbs: Optional[int] = None,
+                 data_storage_size_in_gb: Optional[int] = None,
+                 data_storage_size_limit_in_gbs: Optional[int] = None,
+                 is_auto_expand_storage_enabled: Optional[bool] = None,
+                 max_storage_size_in_gbs: Optional[int] = None):
+        """
+        :param int allocated_storage_size_in_gbs: The actual allocated storage size for the DB System. This may be higher than dataStorageSizeInGBs if an automatic storage expansion has occurred.
+        :param int data_storage_size_in_gb: DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
+        :param int data_storage_size_limit_in_gbs: The absolute limit the DB System's storage size may ever expand to, either manually or automatically. This limit is based based on the initial dataStorageSizeInGBs when the DB System was first created. Both dataStorageSizeInGBs and maxDataStorageSizeInGBs can not exceed this value.
+        :param bool is_auto_expand_storage_enabled: Enable/disable automatic storage expansion. When set to true, the DB System will automatically add storage incrementally up to the value specified in maxStorageSizeInGBs.
+        :param int max_storage_size_in_gbs: Maximum storage size this DB System can expand to. When isAutoExpandStorageEnabled is set to true, the DB System will add storage incrementally up to this value.
+        """
+        if allocated_storage_size_in_gbs is not None:
+            pulumi.set(__self__, "allocated_storage_size_in_gbs", allocated_storage_size_in_gbs)
+        if data_storage_size_in_gb is not None:
+            pulumi.set(__self__, "data_storage_size_in_gb", data_storage_size_in_gb)
+        if data_storage_size_limit_in_gbs is not None:
+            pulumi.set(__self__, "data_storage_size_limit_in_gbs", data_storage_size_limit_in_gbs)
+        if is_auto_expand_storage_enabled is not None:
+            pulumi.set(__self__, "is_auto_expand_storage_enabled", is_auto_expand_storage_enabled)
+        if max_storage_size_in_gbs is not None:
+            pulumi.set(__self__, "max_storage_size_in_gbs", max_storage_size_in_gbs)
+
+    @property
+    @pulumi.getter(name="allocatedStorageSizeInGbs")
+    def allocated_storage_size_in_gbs(self) -> Optional[int]:
+        """
+        The actual allocated storage size for the DB System. This may be higher than dataStorageSizeInGBs if an automatic storage expansion has occurred.
+        """
+        return pulumi.get(self, "allocated_storage_size_in_gbs")
+
+    @property
+    @pulumi.getter(name="dataStorageSizeInGb")
+    def data_storage_size_in_gb(self) -> Optional[int]:
+        """
+        DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
+        """
+        return pulumi.get(self, "data_storage_size_in_gb")
+
+    @property
+    @pulumi.getter(name="dataStorageSizeLimitInGbs")
+    def data_storage_size_limit_in_gbs(self) -> Optional[int]:
+        """
+        The absolute limit the DB System's storage size may ever expand to, either manually or automatically. This limit is based based on the initial dataStorageSizeInGBs when the DB System was first created. Both dataStorageSizeInGBs and maxDataStorageSizeInGBs can not exceed this value.
+        """
+        return pulumi.get(self, "data_storage_size_limit_in_gbs")
+
+    @property
+    @pulumi.getter(name="isAutoExpandStorageEnabled")
+    def is_auto_expand_storage_enabled(self) -> Optional[bool]:
+        """
+        Enable/disable automatic storage expansion. When set to true, the DB System will automatically add storage incrementally up to the value specified in maxStorageSizeInGBs.
+        """
+        return pulumi.get(self, "is_auto_expand_storage_enabled")
+
+    @property
+    @pulumi.getter(name="maxStorageSizeInGbs")
+    def max_storage_size_in_gbs(self) -> Optional[int]:
+        """
+        Maximum storage size this DB System can expand to. When isAutoExpandStorageEnabled is set to true, the DB System will add storage incrementally up to this value.
+        """
+        return pulumi.get(self, "max_storage_size_in_gbs")
+
+
 @pulumi.output_type
 class MysqlBackupDbSystemSnapshotDeletionPolicy(dict):
     @staticmethod
@@ -2945,19 +3057,19 @@ class MysqlDbSystemBackupPolicy(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 defined_tags: Optional[Mapping[str, Any]] = None,
-                 freeform_tags: Optional[Mapping[str, Any]] = None,
+                 defined_tags: Optional[Mapping[str, str]] = None,
+                 freeform_tags: Optional[Mapping[str, str]] = None,
                  is_enabled: Optional[bool] = None,
                  pitr_policy: Optional['outputs.MysqlDbSystemBackupPolicyPitrPolicy'] = None,
                  retention_in_days: Optional[int] = None,
                  window_start_time: Optional[str] = None):
         """
-        :param Mapping[str, Any] defined_tags: (Updatable) Usage of predefined tag keys. These predefined keys are scoped to namespaces.
+        :param Mapping[str, str] defined_tags: (Updatable) Usage of predefined tag keys. These predefined keys are scoped to namespaces.
                
                Tags defined here will be copied verbatim as tags on the Backup resource created by this BackupPolicy.
                
                Example: `{"foo-namespace.bar-key": "value"}`
-        :param Mapping[str, Any] freeform_tags: (Updatable) Simple key-value pair applied without any predefined name, type or scope. Exists for cross-compatibility only.
+        :param Mapping[str, str] freeform_tags: (Updatable) Simple key-value pair applied without any predefined name, type or scope. Exists for cross-compatibility only.
                
                Tags defined here will be copied verbatim as tags on the Backup resource created by this BackupPolicy.
                
@@ -2986,7 +3098,7 @@ class MysqlDbSystemBackupPolicy(dict):
 
     @property
     @pulumi.getter(name="definedTags")
-    def defined_tags(self) -> Optional[Mapping[str, Any]]:
+    def defined_tags(self) -> Optional[Mapping[str, str]]:
         """
         (Updatable) Usage of predefined tag keys. These predefined keys are scoped to namespaces.
 
@@ -2998,7 +3110,7 @@ class MysqlDbSystemBackupPolicy(dict):
 
     @property
     @pulumi.getter(name="freeformTags")
-    def freeform_tags(self) -> Optional[Mapping[str, Any]]:
+    def freeform_tags(self) -> Optional[Mapping[str, str]]:
         """
         (Updatable) Simple key-value pair applied without any predefined name, type or scope. Exists for cross-compatibility only.
 
@@ -3116,9 +3228,9 @@ class MysqlDbSystemChannel(dict):
 
     def __init__(__self__, *,
                  compartment_id: Optional[str] = None,
-                 defined_tags: Optional[Mapping[str, Any]] = None,
+                 defined_tags: Optional[Mapping[str, str]] = None,
                  display_name: Optional[str] = None,
-                 freeform_tags: Optional[Mapping[str, Any]] = None,
+                 freeform_tags: Optional[Mapping[str, str]] = None,
                  id: Optional[str] = None,
                  is_enabled: Optional[bool] = None,
                  lifecycle_details: Optional[str] = None,
@@ -3129,9 +3241,9 @@ class MysqlDbSystemChannel(dict):
                  time_updated: Optional[str] = None):
         """
         :param str compartment_id: The OCID of the compartment.
-        :param Mapping[str, Any] defined_tags: (Updatable) Usage of predefined tag keys. These predefined keys are scoped to namespaces. Example: `{"foo-namespace.bar-key": "value"}`
+        :param Mapping[str, str] defined_tags: (Updatable) Usage of predefined tag keys. These predefined keys are scoped to namespaces. Example: `{"foo-namespace.bar-key": "value"}`
         :param str display_name: (Updatable) The user-friendly name for the DB System. It does not have to be unique.
-        :param Mapping[str, Any] freeform_tags: (Updatable) Simple key-value pair applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
+        :param Mapping[str, str] freeform_tags: (Updatable) Simple key-value pair applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         :param str id: The OCID of the DB System.
         :param bool is_enabled: Whether the Channel has been enabled by the user.
         :param str lifecycle_details: Additional information about the current lifecycleState.
@@ -3176,7 +3288,7 @@ class MysqlDbSystemChannel(dict):
 
     @property
     @pulumi.getter(name="definedTags")
-    def defined_tags(self) -> Optional[Mapping[str, Any]]:
+    def defined_tags(self) -> Optional[Mapping[str, str]]:
         """
         (Updatable) Usage of predefined tag keys. These predefined keys are scoped to namespaces. Example: `{"foo-namespace.bar-key": "value"}`
         """
@@ -3192,7 +3304,7 @@ class MysqlDbSystemChannel(dict):
 
     @property
     @pulumi.getter(name="freeformTags")
-    def freeform_tags(self) -> Optional[Mapping[str, Any]]:
+    def freeform_tags(self) -> Optional[Mapping[str, str]]:
         """
         (Updatable) Simple key-value pair applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         """
@@ -3714,6 +3826,106 @@ class MysqlDbSystemCurrentPlacement(dict):
         return pulumi.get(self, "fault_domain")
 
 
+@pulumi.output_type
+class MysqlDbSystemDataStorage(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "allocatedStorageSizeInGbs":
+            suggest = "allocated_storage_size_in_gbs"
+        elif key == "dataStorageSizeInGb":
+            suggest = "data_storage_size_in_gb"
+        elif key == "dataStorageSizeLimitInGbs":
+            suggest = "data_storage_size_limit_in_gbs"
+        elif key == "isAutoExpandStorageEnabled":
+            suggest = "is_auto_expand_storage_enabled"
+        elif key == "maxStorageSizeInGbs":
+            suggest = "max_storage_size_in_gbs"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in MysqlDbSystemDataStorage. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        MysqlDbSystemDataStorage.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        MysqlDbSystemDataStorage.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 allocated_storage_size_in_gbs: Optional[int] = None,
+                 data_storage_size_in_gb: Optional[int] = None,
+                 data_storage_size_limit_in_gbs: Optional[int] = None,
+                 is_auto_expand_storage_enabled: Optional[bool] = None,
+                 max_storage_size_in_gbs: Optional[int] = None):
+        """
+        :param int allocated_storage_size_in_gbs: The actual allocated storage size for the DB System. This may be higher than dataStorageSizeInGBs if an automatic storage expansion has occurred.
+        :param int data_storage_size_in_gb: (Updatable) Initial size of the data volume in GBs that will be created and attached. Keep in mind that this only specifies the size of the database data volume, the log volume for the database will be scaled appropriately with its shape. It is required if you are creating a new database. It cannot be set if you are creating a database from a backup.
+        :param int data_storage_size_limit_in_gbs: The absolute limit the DB System's storage size may ever expand to, either manually or automatically. This limit is based based on the initial dataStorageSizeInGBs when the DB System was first created. Both dataStorageSizeInGBs and maxDataStorageSizeInGBs can not exceed this value.
+        :param bool is_auto_expand_storage_enabled: (Updatable) Enable/disable automatic storage expansion. When set to true, the DB System will automatically add storage incrementally up to the value specified in maxStorageSizeInGBs.
+        :param int max_storage_size_in_gbs: (Updatable) Maximum storage size this DB System can expand to. When isAutoExpandStorageEnabled is set to true, the DB System will add storage incrementally up to this value.
+               
+               DB Systems with an initial storage size of 400 GB or less can be expanded up to 32 TB. DB Systems with an initial storage size between 401-800 GB can be expanded up to 64 TB. DB Systems with an initial storage size between 801-1200 GB can be expanded up to 96 TB. DB Systems with an initial storage size of 1201 GB or more can be expanded up to 128 TB.
+               
+               It is not possible to decrease data storage size. You cannot set the maximum data storage size to less than either current DB System dataStorageSizeInGBs or allocatedStorageSizeInGBs.
+        """
+        if allocated_storage_size_in_gbs is not None:
+            pulumi.set(__self__, "allocated_storage_size_in_gbs", allocated_storage_size_in_gbs)
+        if data_storage_size_in_gb is not None:
+            pulumi.set(__self__, "data_storage_size_in_gb", data_storage_size_in_gb)
+        if data_storage_size_limit_in_gbs is not None:
+            pulumi.set(__self__, "data_storage_size_limit_in_gbs", data_storage_size_limit_in_gbs)
+        if is_auto_expand_storage_enabled is not None:
+            pulumi.set(__self__, "is_auto_expand_storage_enabled", is_auto_expand_storage_enabled)
+        if max_storage_size_in_gbs is not None:
+            pulumi.set(__self__, "max_storage_size_in_gbs", max_storage_size_in_gbs)
+
+    @property
+    @pulumi.getter(name="allocatedStorageSizeInGbs")
+    def allocated_storage_size_in_gbs(self) -> Optional[int]:
+        """
+        The actual allocated storage size for the DB System. This may be higher than dataStorageSizeInGBs if an automatic storage expansion has occurred.
+        """
+        return pulumi.get(self, "allocated_storage_size_in_gbs")
+
+    @property
+    @pulumi.getter(name="dataStorageSizeInGb")
+    def data_storage_size_in_gb(self) -> Optional[int]:
+        """
+        (Updatable) Initial size of the data volume in GBs that will be created and attached. Keep in mind that this only specifies the size of the database data volume, the log volume for the database will be scaled appropriately with its shape. It is required if you are creating a new database. It cannot be set if you are creating a database from a backup.
+        """
+        return pulumi.get(self, "data_storage_size_in_gb")
+
+    @property
+    @pulumi.getter(name="dataStorageSizeLimitInGbs")
+    def data_storage_size_limit_in_gbs(self) -> Optional[int]:
+        """
+        The absolute limit the DB System's storage size may ever expand to, either manually or automatically. This limit is based based on the initial dataStorageSizeInGBs when the DB System was first created. Both dataStorageSizeInGBs and maxDataStorageSizeInGBs can not exceed this value.
+        """
+        return pulumi.get(self, "data_storage_size_limit_in_gbs")
+
+    @property
+    @pulumi.getter(name="isAutoExpandStorageEnabled")
+    def is_auto_expand_storage_enabled(self) -> Optional[bool]:
+        """
+        (Updatable) Enable/disable automatic storage expansion. When set to true, the DB System will automatically add storage incrementally up to the value specified in maxStorageSizeInGBs.
+        """
+        return pulumi.get(self, "is_auto_expand_storage_enabled")
+
+    @property
+    @pulumi.getter(name="maxStorageSizeInGbs")
+    def max_storage_size_in_gbs(self) -> Optional[int]:
+        """
+        (Updatable) Maximum storage size this DB System can expand to. When isAutoExpandStorageEnabled is set to true, the DB System will add storage incrementally up to this value.
+
+        DB Systems with an initial storage size of 400 GB or less can be expanded up to 32 TB. DB Systems with an initial storage size between 401-800 GB can be expanded up to 64 TB. DB Systems with an initial storage size between 801-1200 GB can be expanded up to 96 TB. DB Systems with an initial storage size of 1201 GB or more can be expanded up to 128 TB.
+
+        It is not possible to decrease data storage size. You cannot set the maximum data storage size to less than either current DB System dataStorageSizeInGBs or allocatedStorageSizeInGBs.
+        """
+        return pulumi.get(self, "max_storage_size_in_gbs")
+
+
 @pulumi.output_type
 class MysqlDbSystemDeletionPolicy(dict):
     @staticmethod
@@ -4675,10 +4887,10 @@ class GetChannelTargetFilterResult(dict):
 class GetChannelsChannelResult(dict):
     def __init__(__self__, *,
                  compartment_id: str,
-                 defined_tags: Mapping[str, Any],
+                 defined_tags: Mapping[str, str],
                  description: str,
                  display_name: str,
-                 freeform_tags: Mapping[str, Any],
+                 freeform_tags: Mapping[str, str],
                  id: str,
                  is_enabled: bool,
                  lifecycle_details: str,
@@ -4689,10 +4901,10 @@ class GetChannelsChannelResult(dict):
                  time_updated: str):
         """
         :param str compartment_id: The compartment [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
-        :param Mapping[str, Any] defined_tags: Usage of predefined tag keys. These predefined keys are scoped to namespaces. Example: `{"foo-namespace.bar-key": "value"}`
+        :param Mapping[str, str] defined_tags: Usage of predefined tag keys. These predefined keys are scoped to namespaces. Example: `{"foo-namespace.bar-key": "value"}`
         :param str description: User provided description of the Channel.
         :param str display_name: A filter to return only the resource matching the given display name exactly.
-        :param Mapping[str, Any] freeform_tags: Simple key-value pair applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
+        :param Mapping[str, str] freeform_tags: Simple key-value pair applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         :param str id: The OCID of the Channel.
         :param bool is_enabled: If true, returns only Channels that are enabled. If false, returns only Channels that are disabled.
         :param str lifecycle_details: A message describing the state of the Channel.
@@ -4726,7 +4938,7 @@ class GetChannelsChannelResult(dict):
 
     @property
     @pulumi.getter(name="definedTags")
-    def defined_tags(self) -> Mapping[str, Any]:
+    def defined_tags(self) -> Mapping[str, str]:
         """
         Usage of predefined tag keys. These predefined keys are scoped to namespaces. Example: `{"foo-namespace.bar-key": "value"}`
         """
@@ -4750,7 +4962,7 @@ class GetChannelsChannelResult(dict):
 
     @property
     @pulumi.getter(name="freeformTags")
-    def freeform_tags(self) -> Mapping[str, Any]:
+    def freeform_tags(self) -> Mapping[str, str]:
         """
         Simple key-value pair applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         """
@@ -5193,14 +5405,15 @@ class GetMysqlBackupDbSystemSnapshotResult(dict):
                  configuration_id: str,
                  crash_recovery: str,
                  data_storage_size_in_gb: int,
+                 data_storages: Sequence['outputs.GetMysqlBackupDbSystemSnapshotDataStorageResult'],
                  database_management: str,
-                 defined_tags: Mapping[str, Any],
+                 defined_tags: Mapping[str, str],
                  deletion_policies: Sequence['outputs.GetMysqlBackupDbSystemSnapshotDeletionPolicyResult'],
                  description: str,
                  display_name: str,
                  endpoints: Sequence['outputs.GetMysqlBackupDbSystemSnapshotEndpointResult'],
                  fault_domain: str,
-                 freeform_tags: Mapping[str, Any],
+                 freeform_tags: Mapping[str, str],
                  hostname_label: str,
                  id: str,
                  ip_address: str,
@@ -5220,15 +5433,16 @@ class GetMysqlBackupDbSystemSnapshotResult(dict):
         :param str compartment_id: The OCID of the compartment the DB System belongs in.
         :param str configuration_id: The OCID of the Configuration to be used for Instances in this DB System.
         :param str crash_recovery: Whether to run the DB System with InnoDB Redo Logs and the Double Write Buffer enabled or disabled, and whether to enable or disable syncing of the Binary Logs.
-        :param int data_storage_size_in_gb: Initial size of the data volume in GiBs that will be created and attached.
+        :param int data_storage_size_in_gb: DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
+        :param Sequence['GetMysqlBackupDbSystemSnapshotDataStorageArgs'] data_storages: Data Storage information.
         :param str database_management: Whether to enable monitoring via the Database Management service.
-        :param Mapping[str, Any] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
+        :param Mapping[str, str] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         :param Sequence['GetMysqlBackupDbSystemSnapshotDeletionPolicyArgs'] deletion_policies: The Deletion policy for the DB System.
         :param str description: A user-supplied description for the backup.
         :param str display_name: A user-supplied display name for the backup.
         :param Sequence['GetMysqlBackupDbSystemSnapshotEndpointArgs'] endpoints: The network endpoints available for this DB System.
         :param str fault_domain: The name of the Fault Domain the DB System is located in.
-        :param Mapping[str, Any] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
+        :param Mapping[str, str] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         :param str hostname_label: The hostname for the primary endpoint of the DB System. Used for DNS. The value is the hostname portion of the primary private IP's fully qualified domain name (FQDN) (for example, "dbsystem-1" in FQDN "dbsystem-1.subnet123.vcn1.oraclevcn.com"). Must be unique across all VNICs in the subnet and comply with RFC 952 and RFC 1123.
         :param str id: OCID of the backup itself
         :param str ip_address: The IP address the DB System is configured to listen on. A private IP address of the primary endpoint of the DB System. Must be an available IP address within the subnet's CIDR. This will be a "dotted-quad" style IPv4 address.
@@ -5249,6 +5463,7 @@ class GetMysqlBackupDbSystemSnapshotResult(dict):
         pulumi.set(__self__, "configuration_id", configuration_id)
         pulumi.set(__self__, "crash_recovery", crash_recovery)
         pulumi.set(__self__, "data_storage_size_in_gb", data_storage_size_in_gb)
+        pulumi.set(__self__, "data_storages", data_storages)
         pulumi.set(__self__, "database_management", database_management)
         pulumi.set(__self__, "defined_tags", defined_tags)
         pulumi.set(__self__, "deletion_policies", deletion_policies)
@@ -5322,10 +5537,18 @@ class GetMysqlBackupDbSystemSnapshotResult(dict):
     @pulumi.getter(name="dataStorageSizeInGb")
     def data_storage_size_in_gb(self) -> int:
         """
-        Initial size of the data volume in GiBs that will be created and attached.
+        DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
         """
         return pulumi.get(self, "data_storage_size_in_gb")
 
+    @property
+    @pulumi.getter(name="dataStorages")
+    def data_storages(self) -> Sequence['outputs.GetMysqlBackupDbSystemSnapshotDataStorageResult']:
+        """
+        Data Storage information.
+        """
+        return pulumi.get(self, "data_storages")
+
     @property
     @pulumi.getter(name="databaseManagement")
     def database_management(self) -> str:
@@ -5336,7 +5559,7 @@ class GetMysqlBackupDbSystemSnapshotResult(dict):
 
     @property
     @pulumi.getter(name="definedTags")
-    def defined_tags(self) -> Mapping[str, Any]:
+    def defined_tags(self) -> Mapping[str, str]:
         """
         Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         """
@@ -5384,7 +5607,7 @@ class GetMysqlBackupDbSystemSnapshotResult(dict):
 
     @property
     @pulumi.getter(name="freeformTags")
-    def freeform_tags(self) -> Mapping[str, Any]:
+    def freeform_tags(self) -> Mapping[str, str]:
         """
         Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         """
@@ -5490,15 +5713,15 @@ class GetMysqlBackupDbSystemSnapshotResult(dict):
 @pulumi.output_type
 class GetMysqlBackupDbSystemSnapshotBackupPolicyResult(dict):
     def __init__(__self__, *,
-                 defined_tags: Mapping[str, Any],
-                 freeform_tags: Mapping[str, Any],
+                 defined_tags: Mapping[str, str],
+                 freeform_tags: Mapping[str, str],
                  is_enabled: bool,
                  pitr_policies: Sequence['outputs.GetMysqlBackupDbSystemSnapshotBackupPolicyPitrPolicyResult'],
                  retention_in_days: int,
                  window_start_time: str):
         """
-        :param Mapping[str, Any] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
-        :param Mapping[str, Any] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
+        :param Mapping[str, str] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
+        :param Mapping[str, str] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         :param bool is_enabled: Specifies if PITR is enabled or disabled.
         :param Sequence['GetMysqlBackupDbSystemSnapshotBackupPolicyPitrPolicyArgs'] pitr_policies: The PITR policy for the DB System.
         :param int retention_in_days: Number of days to retain this backup.
@@ -5513,7 +5736,7 @@ class GetMysqlBackupDbSystemSnapshotBackupPolicyResult(dict):
 
     @property
     @pulumi.getter(name="definedTags")
-    def defined_tags(self) -> Mapping[str, Any]:
+    def defined_tags(self) -> Mapping[str, str]:
         """
         Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         """
@@ -5521,7 +5744,7 @@ class GetMysqlBackupDbSystemSnapshotBackupPolicyResult(dict):
 
     @property
     @pulumi.getter(name="freeformTags")
-    def freeform_tags(self) -> Mapping[str, Any]:
+    def freeform_tags(self) -> Mapping[str, str]:
         """
         Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         """
@@ -5578,6 +5801,68 @@ class GetMysqlBackupDbSystemSnapshotBackupPolicyPitrPolicyResult(dict):
         return pulumi.get(self, "is_enabled")
 
 
+@pulumi.output_type
+class GetMysqlBackupDbSystemSnapshotDataStorageResult(dict):
+    def __init__(__self__, *,
+                 allocated_storage_size_in_gbs: int,
+                 data_storage_size_in_gb: int,
+                 data_storage_size_limit_in_gbs: int,
+                 is_auto_expand_storage_enabled: bool,
+                 max_storage_size_in_gbs: int):
+        """
+        :param int allocated_storage_size_in_gbs: The actual allocated storage size for the DB System. This may be higher than dataStorageSizeInGBs if an automatic storage expansion has occurred.
+        :param int data_storage_size_in_gb: DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
+        :param int data_storage_size_limit_in_gbs: The absolute limit the DB System's storage size may ever expand to, either manually or automatically. This limit is based based on the initial dataStorageSizeInGBs when the DB System was first created. Both dataStorageSizeInGBs and maxDataStorageSizeInGBs can not exceed this value.
+        :param bool is_auto_expand_storage_enabled: Enable/disable automatic storage expansion. When set to true, the DB System will automatically add storage incrementally up to the value specified in maxStorageSizeInGBs.
+        :param int max_storage_size_in_gbs: Maximum storage size this DB System can expand to. When isAutoExpandStorageEnabled is set to true, the DB System will add storage incrementally up to this value.
+        """
+        pulumi.set(__self__, "allocated_storage_size_in_gbs", allocated_storage_size_in_gbs)
+        pulumi.set(__self__, "data_storage_size_in_gb", data_storage_size_in_gb)
+        pulumi.set(__self__, "data_storage_size_limit_in_gbs", data_storage_size_limit_in_gbs)
+        pulumi.set(__self__, "is_auto_expand_storage_enabled", is_auto_expand_storage_enabled)
+        pulumi.set(__self__, "max_storage_size_in_gbs", max_storage_size_in_gbs)
+
+    @property
+    @pulumi.getter(name="allocatedStorageSizeInGbs")
+    def allocated_storage_size_in_gbs(self) -> int:
+        """
+        The actual allocated storage size for the DB System. This may be higher than dataStorageSizeInGBs if an automatic storage expansion has occurred.
+        """
+        return pulumi.get(self, "allocated_storage_size_in_gbs")
+
+    @property
+    @pulumi.getter(name="dataStorageSizeInGb")
+    def data_storage_size_in_gb(self) -> int:
+        """
+        DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
+        """
+        return pulumi.get(self, "data_storage_size_in_gb")
+
+    @property
+    @pulumi.getter(name="dataStorageSizeLimitInGbs")
+    def data_storage_size_limit_in_gbs(self) -> int:
+        """
+        The absolute limit the DB System's storage size may ever expand to, either manually or automatically. This limit is based based on the initial dataStorageSizeInGBs when the DB System was first created. Both dataStorageSizeInGBs and maxDataStorageSizeInGBs can not exceed this value.
+        """
+        return pulumi.get(self, "data_storage_size_limit_in_gbs")
+
+    @property
+    @pulumi.getter(name="isAutoExpandStorageEnabled")
+    def is_auto_expand_storage_enabled(self) -> bool:
+        """
+        Enable/disable automatic storage expansion. When set to true, the DB System will automatically add storage incrementally up to the value specified in maxStorageSizeInGBs.
+        """
+        return pulumi.get(self, "is_auto_expand_storage_enabled")
+
+    @property
+    @pulumi.getter(name="maxStorageSizeInGbs")
+    def max_storage_size_in_gbs(self) -> int:
+        """
+        Maximum storage size this DB System can expand to. When isAutoExpandStorageEnabled is set to true, the DB System will add storage incrementally up to this value.
+        """
+        return pulumi.get(self, "max_storage_size_in_gbs")
+
+
 @pulumi.output_type
 class GetMysqlBackupDbSystemSnapshotDeletionPolicyResult(dict):
     def __init__(__self__, *,
@@ -5862,10 +6147,10 @@ class GetMysqlBackupsBackupResult(dict):
                  db_system_id: str,
                  db_system_snapshot_summaries: Sequence['outputs.GetMysqlBackupsBackupDbSystemSnapshotSummaryResult'],
                  db_system_snapshots: Sequence['outputs.GetMysqlBackupsBackupDbSystemSnapshotResult'],
-                 defined_tags: Mapping[str, Any],
+                 defined_tags: Mapping[str, str],
                  description: str,
                  display_name: str,
-                 freeform_tags: Mapping[str, Any],
+                 freeform_tags: Mapping[str, str],
                  id: str,
                  immediate_source_backup_id: str,
                  lifecycle_details: str,
@@ -5883,13 +6168,13 @@ class GetMysqlBackupsBackupResult(dict):
         :param str backup_type: The type of backup.
         :param str compartment_id: The compartment [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
         :param str creation_type: Backup creationType
-        :param int data_storage_size_in_gb: Initial size of the data volume in GiBs that will be created and attached.
+        :param int data_storage_size_in_gb: DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
         :param str db_system_id: The DB System [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
         :param Sequence['GetMysqlBackupsBackupDbSystemSnapshotArgs'] db_system_snapshots: Snapshot of the DbSystem details at the time of the backup
-        :param Mapping[str, Any] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
+        :param Mapping[str, str] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         :param str description: A user-supplied description for the backup.
         :param str display_name: A filter to return only the resource matching the given display name exactly.
-        :param Mapping[str, Any] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
+        :param Mapping[str, str] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         :param str id: OCID of the backup itself
         :param str immediate_source_backup_id: The OCID of the immediate source DB system backup from which this DB system backup was copied.
         :param str lifecycle_details: Additional information about the current lifecycleState.
@@ -5963,7 +6248,7 @@ class GetMysqlBackupsBackupResult(dict):
     @pulumi.getter(name="dataStorageSizeInGb")
     def data_storage_size_in_gb(self) -> int:
         """
-        Initial size of the data volume in GiBs that will be created and attached.
+        DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
         """
         return pulumi.get(self, "data_storage_size_in_gb")
 
@@ -5990,7 +6275,7 @@ class GetMysqlBackupsBackupResult(dict):
 
     @property
     @pulumi.getter(name="definedTags")
-    def defined_tags(self) -> Mapping[str, Any]:
+    def defined_tags(self) -> Mapping[str, str]:
         """
         Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         """
@@ -6014,7 +6299,7 @@ class GetMysqlBackupsBackupResult(dict):
 
     @property
     @pulumi.getter(name="freeformTags")
-    def freeform_tags(self) -> Mapping[str, Any]:
+    def freeform_tags(self) -> Mapping[str, str]:
         """
         Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         """
@@ -6124,14 +6409,15 @@ class GetMysqlBackupsBackupDbSystemSnapshotResult(dict):
                  configuration_id: str,
                  crash_recovery: str,
                  data_storage_size_in_gb: int,
+                 data_storages: Sequence['outputs.GetMysqlBackupsBackupDbSystemSnapshotDataStorageResult'],
                  database_management: str,
-                 defined_tags: Mapping[str, Any],
+                 defined_tags: Mapping[str, str],
                  deletion_policies: Sequence['outputs.GetMysqlBackupsBackupDbSystemSnapshotDeletionPolicyResult'],
                  description: str,
                  display_name: str,
                  endpoints: Sequence['outputs.GetMysqlBackupsBackupDbSystemSnapshotEndpointResult'],
                  fault_domain: str,
-                 freeform_tags: Mapping[str, Any],
+                 freeform_tags: Mapping[str, str],
                  hostname_label: str,
                  id: str,
                  ip_address: str,
@@ -6151,15 +6437,16 @@ class GetMysqlBackupsBackupDbSystemSnapshotResult(dict):
         :param str compartment_id: The compartment [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
         :param str configuration_id: The OCID of the Configuration to be used for Instances in this DB System.
         :param str crash_recovery: Whether to run the DB System with InnoDB Redo Logs and the Double Write Buffer enabled or disabled, and whether to enable or disable syncing of the Binary Logs.
-        :param int data_storage_size_in_gb: Initial size of the data volume in GiBs that will be created and attached.
+        :param int data_storage_size_in_gb: DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
+        :param Sequence['GetMysqlBackupsBackupDbSystemSnapshotDataStorageArgs'] data_storages: Data Storage information.
         :param str database_management: Whether to enable monitoring via the Database Management service.
-        :param Mapping[str, Any] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
+        :param Mapping[str, str] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         :param Sequence['GetMysqlBackupsBackupDbSystemSnapshotDeletionPolicyArgs'] deletion_policies: The Deletion policy for the DB System.
         :param str description: A user-supplied description for the backup.
         :param str display_name: A filter to return only the resource matching the given display name exactly.
         :param Sequence['GetMysqlBackupsBackupDbSystemSnapshotEndpointArgs'] endpoints: The network endpoints available for this DB System.
         :param str fault_domain: The name of the Fault Domain the DB System is located in.
-        :param Mapping[str, Any] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
+        :param Mapping[str, str] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         :param str hostname_label: The hostname for the primary endpoint of the DB System. Used for DNS. The value is the hostname portion of the primary private IP's fully qualified domain name (FQDN) (for example, "dbsystem-1" in FQDN "dbsystem-1.subnet123.vcn1.oraclevcn.com"). Must be unique across all VNICs in the subnet and comply with RFC 952 and RFC 1123.
         :param str id: OCID of the backup itself
         :param str ip_address: The IP address the DB System is configured to listen on. A private IP address of the primary endpoint of the DB System. Must be an available IP address within the subnet's CIDR. This will be a "dotted-quad" style IPv4 address.
@@ -6180,6 +6467,7 @@ class GetMysqlBackupsBackupDbSystemSnapshotResult(dict):
         pulumi.set(__self__, "configuration_id", configuration_id)
         pulumi.set(__self__, "crash_recovery", crash_recovery)
         pulumi.set(__self__, "data_storage_size_in_gb", data_storage_size_in_gb)
+        pulumi.set(__self__, "data_storages", data_storages)
         pulumi.set(__self__, "database_management", database_management)
         pulumi.set(__self__, "defined_tags", defined_tags)
         pulumi.set(__self__, "deletion_policies", deletion_policies)
@@ -6253,10 +6541,18 @@ class GetMysqlBackupsBackupDbSystemSnapshotResult(dict):
     @pulumi.getter(name="dataStorageSizeInGb")
     def data_storage_size_in_gb(self) -> int:
         """
-        Initial size of the data volume in GiBs that will be created and attached.
+        DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
         """
         return pulumi.get(self, "data_storage_size_in_gb")
 
+    @property
+    @pulumi.getter(name="dataStorages")
+    def data_storages(self) -> Sequence['outputs.GetMysqlBackupsBackupDbSystemSnapshotDataStorageResult']:
+        """
+        Data Storage information.
+        """
+        return pulumi.get(self, "data_storages")
+
     @property
     @pulumi.getter(name="databaseManagement")
     def database_management(self) -> str:
@@ -6267,7 +6563,7 @@ class GetMysqlBackupsBackupDbSystemSnapshotResult(dict):
 
     @property
     @pulumi.getter(name="definedTags")
-    def defined_tags(self) -> Mapping[str, Any]:
+    def defined_tags(self) -> Mapping[str, str]:
         """
         Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         """
@@ -6315,7 +6611,7 @@ class GetMysqlBackupsBackupDbSystemSnapshotResult(dict):
 
     @property
     @pulumi.getter(name="freeformTags")
-    def freeform_tags(self) -> Mapping[str, Any]:
+    def freeform_tags(self) -> Mapping[str, str]:
         """
         Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         """
@@ -6421,15 +6717,15 @@ class GetMysqlBackupsBackupDbSystemSnapshotResult(dict):
 @pulumi.output_type
 class GetMysqlBackupsBackupDbSystemSnapshotBackupPolicyResult(dict):
     def __init__(__self__, *,
-                 defined_tags: Mapping[str, Any],
-                 freeform_tags: Mapping[str, Any],
+                 defined_tags: Mapping[str, str],
+                 freeform_tags: Mapping[str, str],
                  is_enabled: bool,
                  pitr_policies: Sequence['outputs.GetMysqlBackupsBackupDbSystemSnapshotBackupPolicyPitrPolicyResult'],
                  retention_in_days: int,
                  window_start_time: str):
         """
-        :param Mapping[str, Any] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
-        :param Mapping[str, Any] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
+        :param Mapping[str, str] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
+        :param Mapping[str, str] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         :param bool is_enabled: Specifies if PITR is enabled or disabled.
         :param Sequence['GetMysqlBackupsBackupDbSystemSnapshotBackupPolicyPitrPolicyArgs'] pitr_policies: The PITR policy for the DB System.
         :param int retention_in_days: Number of days to retain this backup.
@@ -6444,7 +6740,7 @@ class GetMysqlBackupsBackupDbSystemSnapshotBackupPolicyResult(dict):
 
     @property
     @pulumi.getter(name="definedTags")
-    def defined_tags(self) -> Mapping[str, Any]:
+    def defined_tags(self) -> Mapping[str, str]:
         """
         Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         """
@@ -6452,7 +6748,7 @@ class GetMysqlBackupsBackupDbSystemSnapshotBackupPolicyResult(dict):
 
     @property
     @pulumi.getter(name="freeformTags")
-    def freeform_tags(self) -> Mapping[str, Any]:
+    def freeform_tags(self) -> Mapping[str, str]:
         """
         Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         """
@@ -6509,6 +6805,68 @@ class GetMysqlBackupsBackupDbSystemSnapshotBackupPolicyPitrPolicyResult(dict):
         return pulumi.get(self, "is_enabled")
 
 
+@pulumi.output_type
+class GetMysqlBackupsBackupDbSystemSnapshotDataStorageResult(dict):
+    def __init__(__self__, *,
+                 allocated_storage_size_in_gbs: int,
+                 data_storage_size_in_gb: int,
+                 data_storage_size_limit_in_gbs: int,
+                 is_auto_expand_storage_enabled: bool,
+                 max_storage_size_in_gbs: int):
+        """
+        :param int allocated_storage_size_in_gbs: The actual allocated storage size for the DB System. This may be higher than dataStorageSizeInGBs if an automatic storage expansion has occurred.
+        :param int data_storage_size_in_gb: DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
+        :param int data_storage_size_limit_in_gbs: The absolute limit the DB System's storage size may ever expand to, either manually or automatically. This limit is based based on the initial dataStorageSizeInGBs when the DB System was first created. Both dataStorageSizeInGBs and maxDataStorageSizeInGBs can not exceed this value.
+        :param bool is_auto_expand_storage_enabled: Enable/disable automatic storage expansion. When set to true, the DB System will automatically add storage incrementally up to the value specified in maxStorageSizeInGBs.
+        :param int max_storage_size_in_gbs: Maximum storage size this DB System can expand to. When isAutoExpandStorageEnabled is set to true, the DB System will add storage incrementally up to this value.
+        """
+        pulumi.set(__self__, "allocated_storage_size_in_gbs", allocated_storage_size_in_gbs)
+        pulumi.set(__self__, "data_storage_size_in_gb", data_storage_size_in_gb)
+        pulumi.set(__self__, "data_storage_size_limit_in_gbs", data_storage_size_limit_in_gbs)
+        pulumi.set(__self__, "is_auto_expand_storage_enabled", is_auto_expand_storage_enabled)
+        pulumi.set(__self__, "max_storage_size_in_gbs", max_storage_size_in_gbs)
+
+    @property
+    @pulumi.getter(name="allocatedStorageSizeInGbs")
+    def allocated_storage_size_in_gbs(self) -> int:
+        """
+        The actual allocated storage size for the DB System. This may be higher than dataStorageSizeInGBs if an automatic storage expansion has occurred.
+        """
+        return pulumi.get(self, "allocated_storage_size_in_gbs")
+
+    @property
+    @pulumi.getter(name="dataStorageSizeInGb")
+    def data_storage_size_in_gb(self) -> int:
+        """
+        DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
+        """
+        return pulumi.get(self, "data_storage_size_in_gb")
+
+    @property
+    @pulumi.getter(name="dataStorageSizeLimitInGbs")
+    def data_storage_size_limit_in_gbs(self) -> int:
+        """
+        The absolute limit the DB System's storage size may ever expand to, either manually or automatically. This limit is based based on the initial dataStorageSizeInGBs when the DB System was first created. Both dataStorageSizeInGBs and maxDataStorageSizeInGBs can not exceed this value.
+        """
+        return pulumi.get(self, "data_storage_size_limit_in_gbs")
+
+    @property
+    @pulumi.getter(name="isAutoExpandStorageEnabled")
+    def is_auto_expand_storage_enabled(self) -> bool:
+        """
+        Enable/disable automatic storage expansion. When set to true, the DB System will automatically add storage incrementally up to the value specified in maxStorageSizeInGBs.
+        """
+        return pulumi.get(self, "is_auto_expand_storage_enabled")
+
+    @property
+    @pulumi.getter(name="maxStorageSizeInGbs")
+    def max_storage_size_in_gbs(self) -> int:
+        """
+        Maximum storage size this DB System can expand to. When isAutoExpandStorageEnabled is set to true, the DB System will add storage incrementally up to this value.
+        """
+        return pulumi.get(self, "max_storage_size_in_gbs")
+
+
 @pulumi.output_type
 class GetMysqlBackupsBackupDbSystemSnapshotDeletionPolicyResult(dict):
     def __init__(__self__, *,
@@ -7722,10 +8080,10 @@ class GetMysqlConfigurationVariableResult(dict):
 class GetMysqlConfigurationsConfigurationResult(dict):
     def __init__(__self__, *,
                  compartment_id: str,
-                 defined_tags: Mapping[str, Any],
+                 defined_tags: Mapping[str, str],
                  description: str,
                  display_name: str,
-                 freeform_tags: Mapping[str, Any],
+                 freeform_tags: Mapping[str, str],
                  id: str,
                  init_variables: Sequence['outputs.GetMysqlConfigurationsConfigurationInitVariableResult'],
                  parent_configuration_id: str,
@@ -7737,10 +8095,10 @@ class GetMysqlConfigurationsConfigurationResult(dict):
                  variables: Sequence['outputs.GetMysqlConfigurationsConfigurationVariableResult']):
         """
         :param str compartment_id: The compartment [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
-        :param Mapping[str, Any] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
+        :param Mapping[str, str] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         :param str description: User-provided data about the Configuration.
         :param str display_name: A filter to return only the resource matching the given display name exactly.
-        :param Mapping[str, Any] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
+        :param Mapping[str, str] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         :param str id: The OCID of the Configuration.
         :param Sequence['GetMysqlConfigurationsConfigurationInitVariableArgs'] init_variables: User-defined service variables set only at DB system initialization. These variables cannot be changed later at runtime.
         :param str parent_configuration_id: The OCID of the Configuration from which this Configuration is "derived". This is entirely a metadata relationship. There is no relation between the values in this Configuration and its parent.
@@ -7776,7 +8134,7 @@ class GetMysqlConfigurationsConfigurationResult(dict):
 
     @property
     @pulumi.getter(name="definedTags")
-    def defined_tags(self) -> Mapping[str, Any]:
+    def defined_tags(self) -> Mapping[str, str]:
         """
         Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         """
@@ -7800,7 +8158,7 @@ class GetMysqlConfigurationsConfigurationResult(dict):
 
     @property
     @pulumi.getter(name="freeformTags")
-    def freeform_tags(self) -> Mapping[str, Any]:
+    def freeform_tags(self) -> Mapping[str, str]:
         """
         Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         """
@@ -8818,15 +9176,15 @@ class GetMysqlConfigurationsFilterResult(dict):
 @pulumi.output_type
 class GetMysqlDbSystemBackupPolicyResult(dict):
     def __init__(__self__, *,
-                 defined_tags: Mapping[str, Any],
-                 freeform_tags: Mapping[str, Any],
+                 defined_tags: Mapping[str, str],
+                 freeform_tags: Mapping[str, str],
                  is_enabled: bool,
                  pitr_policies: Sequence['outputs.GetMysqlDbSystemBackupPolicyPitrPolicyResult'],
                  retention_in_days: int,
                  window_start_time: str):
         """
-        :param Mapping[str, Any] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
-        :param Mapping[str, Any] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
+        :param Mapping[str, str] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
+        :param Mapping[str, str] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         :param bool is_enabled: Whether the Channel has been enabled by the user.
         :param Sequence['GetMysqlDbSystemBackupPolicyPitrPolicyArgs'] pitr_policies: The PITR policy for the DB System.
         :param int retention_in_days: The number of days automated backups are retained.
@@ -8841,7 +9199,7 @@ class GetMysqlDbSystemBackupPolicyResult(dict):
 
     @property
     @pulumi.getter(name="definedTags")
-    def defined_tags(self) -> Mapping[str, Any]:
+    def defined_tags(self) -> Mapping[str, str]:
         """
         Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         """
@@ -8849,7 +9207,7 @@ class GetMysqlDbSystemBackupPolicyResult(dict):
 
     @property
     @pulumi.getter(name="freeformTags")
-    def freeform_tags(self) -> Mapping[str, Any]:
+    def freeform_tags(self) -> Mapping[str, str]:
         """
         Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         """
@@ -8910,9 +9268,9 @@ class GetMysqlDbSystemBackupPolicyPitrPolicyResult(dict):
 class GetMysqlDbSystemChannelResult(dict):
     def __init__(__self__, *,
                  compartment_id: str,
-                 defined_tags: Mapping[str, Any],
+                 defined_tags: Mapping[str, str],
                  display_name: str,
-                 freeform_tags: Mapping[str, Any],
+                 freeform_tags: Mapping[str, str],
                  id: str,
                  is_enabled: bool,
                  lifecycle_details: str,
@@ -8923,9 +9281,9 @@ class GetMysqlDbSystemChannelResult(dict):
                  time_updated: str):
         """
         :param str compartment_id: The OCID of the compartment the DB System belongs in.
-        :param Mapping[str, Any] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
+        :param Mapping[str, str] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         :param str display_name: The user-friendly name for the DB System. It does not have to be unique.
-        :param Mapping[str, Any] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
+        :param Mapping[str, str] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         :param str id: The OCID of the DB System.
         :param bool is_enabled: Whether the Channel has been enabled by the user.
         :param str lifecycle_details: Additional information about the current lifecycleState.
@@ -8958,7 +9316,7 @@ class GetMysqlDbSystemChannelResult(dict):
 
     @property
     @pulumi.getter(name="definedTags")
-    def defined_tags(self) -> Mapping[str, Any]:
+    def defined_tags(self) -> Mapping[str, str]:
         """
         Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         """
@@ -8974,7 +9332,7 @@ class GetMysqlDbSystemChannelResult(dict):
 
     @property
     @pulumi.getter(name="freeformTags")
-    def freeform_tags(self) -> Mapping[str, Any]:
+    def freeform_tags(self) -> Mapping[str, str]:
         """
         Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         """
@@ -9351,6 +9709,68 @@ class GetMysqlDbSystemCurrentPlacementResult(dict):
         return pulumi.get(self, "fault_domain")
 
 
+@pulumi.output_type
+class GetMysqlDbSystemDataStorageResult(dict):
+    def __init__(__self__, *,
+                 allocated_storage_size_in_gbs: int,
+                 data_storage_size_in_gb: int,
+                 data_storage_size_limit_in_gbs: int,
+                 is_auto_expand_storage_enabled: bool,
+                 max_storage_size_in_gbs: int):
+        """
+        :param int allocated_storage_size_in_gbs: The actual allocated storage size for the DB System. This may be higher than dataStorageSizeInGBs if an automatic storage expansion has occurred.
+        :param int data_storage_size_in_gb: DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
+        :param int data_storage_size_limit_in_gbs: The absolute limit the DB System's storage size may ever expand to, either manually or automatically. This limit is based based on the initial dataStorageSizeInGBs when the DB System was first created. Both dataStorageSizeInGBs and maxDataStorageSizeInGBs can not exceed this value.
+        :param bool is_auto_expand_storage_enabled: Enable/disable automatic storage expansion. When set to true, the DB System will automatically add storage incrementally up to the value specified in maxStorageSizeInGBs.
+        :param int max_storage_size_in_gbs: Maximum storage size this DB System can expand to. When isAutoExpandStorageEnabled is set to true, the DB System will add storage incrementally up to this value.
+        """
+        pulumi.set(__self__, "allocated_storage_size_in_gbs", allocated_storage_size_in_gbs)
+        pulumi.set(__self__, "data_storage_size_in_gb", data_storage_size_in_gb)
+        pulumi.set(__self__, "data_storage_size_limit_in_gbs", data_storage_size_limit_in_gbs)
+        pulumi.set(__self__, "is_auto_expand_storage_enabled", is_auto_expand_storage_enabled)
+        pulumi.set(__self__, "max_storage_size_in_gbs", max_storage_size_in_gbs)
+
+    @property
+    @pulumi.getter(name="allocatedStorageSizeInGbs")
+    def allocated_storage_size_in_gbs(self) -> int:
+        """
+        The actual allocated storage size for the DB System. This may be higher than dataStorageSizeInGBs if an automatic storage expansion has occurred.
+        """
+        return pulumi.get(self, "allocated_storage_size_in_gbs")
+
+    @property
+    @pulumi.getter(name="dataStorageSizeInGb")
+    def data_storage_size_in_gb(self) -> int:
+        """
+        DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
+        """
+        return pulumi.get(self, "data_storage_size_in_gb")
+
+    @property
+    @pulumi.getter(name="dataStorageSizeLimitInGbs")
+    def data_storage_size_limit_in_gbs(self) -> int:
+        """
+        The absolute limit the DB System's storage size may ever expand to, either manually or automatically. This limit is based based on the initial dataStorageSizeInGBs when the DB System was first created. Both dataStorageSizeInGBs and maxDataStorageSizeInGBs can not exceed this value.
+        """
+        return pulumi.get(self, "data_storage_size_limit_in_gbs")
+
+    @property
+    @pulumi.getter(name="isAutoExpandStorageEnabled")
+    def is_auto_expand_storage_enabled(self) -> bool:
+        """
+        Enable/disable automatic storage expansion. When set to true, the DB System will automatically add storage incrementally up to the value specified in maxStorageSizeInGBs.
+        """
+        return pulumi.get(self, "is_auto_expand_storage_enabled")
+
+    @property
+    @pulumi.getter(name="maxStorageSizeInGbs")
+    def max_storage_size_in_gbs(self) -> int:
+        """
+        Maximum storage size this DB System can expand to. When isAutoExpandStorageEnabled is set to true, the DB System will add storage incrementally up to this value.
+        """
+        return pulumi.get(self, "max_storage_size_in_gbs")
+
+
 @pulumi.output_type
 class GetMysqlDbSystemDeletionPolicyResult(dict):
     def __init__(__self__, *,
@@ -9717,14 +10137,15 @@ class GetMysqlDbSystemsDbSystemResult(dict):
                  crash_recovery: str,
                  current_placements: Sequence['outputs.GetMysqlDbSystemsDbSystemCurrentPlacementResult'],
                  data_storage_size_in_gb: int,
+                 data_storages: Sequence['outputs.GetMysqlDbSystemsDbSystemDataStorageResult'],
                  database_management: str,
-                 defined_tags: Mapping[str, Any],
+                 defined_tags: Mapping[str, str],
                  deletion_policies: Sequence['outputs.GetMysqlDbSystemsDbSystemDeletionPolicyResult'],
                  description: str,
                  display_name: str,
                  endpoints: Sequence['outputs.GetMysqlDbSystemsDbSystemEndpointResult'],
                  fault_domain: str,
-                 freeform_tags: Mapping[str, Any],
+                 freeform_tags: Mapping[str, str],
                  heat_wave_clusters: Sequence['outputs.GetMysqlDbSystemsDbSystemHeatWaveClusterResult'],
                  hostname_label: str,
                  id: str,
@@ -9753,15 +10174,16 @@ class GetMysqlDbSystemsDbSystemResult(dict):
         :param str configuration_id: The requested Configuration instance.
         :param str crash_recovery: Whether to run the DB System with InnoDB Redo Logs and the Double Write Buffer enabled or disabled, and whether to enable or disable syncing of the Binary Logs.
         :param Sequence['GetMysqlDbSystemsDbSystemCurrentPlacementArgs'] current_placements: The availability domain and fault domain a DB System is placed in.
-        :param int data_storage_size_in_gb: Initial size of the data volume in GiBs that will be created and attached.
+        :param int data_storage_size_in_gb: DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
+        :param Sequence['GetMysqlDbSystemsDbSystemDataStorageArgs'] data_storages: Data Storage information.
         :param str database_management: Filter DB Systems by their Database Management configuration.
-        :param Mapping[str, Any] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
+        :param Mapping[str, str] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         :param Sequence['GetMysqlDbSystemsDbSystemDeletionPolicyArgs'] deletion_policies: The Deletion policy for the DB System.
         :param str description: User-provided data about the DB System.
         :param str display_name: A filter to return only the resource matching the given display name exactly.
         :param Sequence['GetMysqlDbSystemsDbSystemEndpointArgs'] endpoints: The network endpoints available for this DB System.
         :param str fault_domain: The fault domain on which to deploy the Read/Write endpoint. This defines the preferred primary instance.
-        :param Mapping[str, Any] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
+        :param Mapping[str, str] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         :param Sequence['GetMysqlDbSystemsDbSystemHeatWaveClusterArgs'] heat_wave_clusters: A summary of a HeatWave cluster.
         :param str hostname_label: The hostname for the primary endpoint of the DB System. Used for DNS. The value is the hostname portion of the primary private IP's fully qualified domain name (FQDN) (for example, "dbsystem-1" in FQDN "dbsystem-1.subnet123.vcn1.oraclevcn.com"). Must be unique across all VNICs in the subnet and comply with RFC 952 and RFC 1123.
         :param str id: The OCID of the DB System.
@@ -9792,6 +10214,7 @@ class GetMysqlDbSystemsDbSystemResult(dict):
         pulumi.set(__self__, "crash_recovery", crash_recovery)
         pulumi.set(__self__, "current_placements", current_placements)
         pulumi.set(__self__, "data_storage_size_in_gb", data_storage_size_in_gb)
+        pulumi.set(__self__, "data_storages", data_storages)
         pulumi.set(__self__, "database_management", database_management)
         pulumi.set(__self__, "defined_tags", defined_tags)
         pulumi.set(__self__, "deletion_policies", deletion_policies)
@@ -9891,10 +10314,18 @@ class GetMysqlDbSystemsDbSystemResult(dict):
     @pulumi.getter(name="dataStorageSizeInGb")
     def data_storage_size_in_gb(self) -> int:
         """
-        Initial size of the data volume in GiBs that will be created and attached.
+        DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
         """
         return pulumi.get(self, "data_storage_size_in_gb")
 
+    @property
+    @pulumi.getter(name="dataStorages")
+    def data_storages(self) -> Sequence['outputs.GetMysqlDbSystemsDbSystemDataStorageResult']:
+        """
+        Data Storage information.
+        """
+        return pulumi.get(self, "data_storages")
+
     @property
     @pulumi.getter(name="databaseManagement")
     def database_management(self) -> str:
@@ -9905,7 +10336,7 @@ class GetMysqlDbSystemsDbSystemResult(dict):
 
     @property
     @pulumi.getter(name="definedTags")
-    def defined_tags(self) -> Mapping[str, Any]:
+    def defined_tags(self) -> Mapping[str, str]:
         """
         Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         """
@@ -9953,7 +10384,7 @@ class GetMysqlDbSystemsDbSystemResult(dict):
 
     @property
     @pulumi.getter(name="freeformTags")
-    def freeform_tags(self) -> Mapping[str, Any]:
+    def freeform_tags(self) -> Mapping[str, str]:
         """
         Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         """
@@ -10120,15 +10551,15 @@ class GetMysqlDbSystemsDbSystemResult(dict):
 @pulumi.output_type
 class GetMysqlDbSystemsDbSystemBackupPolicyResult(dict):
     def __init__(__self__, *,
-                 defined_tags: Mapping[str, Any],
-                 freeform_tags: Mapping[str, Any],
+                 defined_tags: Mapping[str, str],
+                 freeform_tags: Mapping[str, str],
                  is_enabled: bool,
                  pitr_policies: Sequence['outputs.GetMysqlDbSystemsDbSystemBackupPolicyPitrPolicyResult'],
                  retention_in_days: int,
                  window_start_time: str):
         """
-        :param Mapping[str, Any] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
-        :param Mapping[str, Any] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
+        :param Mapping[str, str] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
+        :param Mapping[str, str] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         :param bool is_enabled: Whether the Channel has been enabled by the user.
         :param Sequence['GetMysqlDbSystemsDbSystemBackupPolicyPitrPolicyArgs'] pitr_policies: The PITR policy for the DB System.
         :param int retention_in_days: The number of days automated backups are retained.
@@ -10143,7 +10574,7 @@ class GetMysqlDbSystemsDbSystemBackupPolicyResult(dict):
 
     @property
     @pulumi.getter(name="definedTags")
-    def defined_tags(self) -> Mapping[str, Any]:
+    def defined_tags(self) -> Mapping[str, str]:
         """
         Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         """
@@ -10151,7 +10582,7 @@ class GetMysqlDbSystemsDbSystemBackupPolicyResult(dict):
 
     @property
     @pulumi.getter(name="freeformTags")
-    def freeform_tags(self) -> Mapping[str, Any]:
+    def freeform_tags(self) -> Mapping[str, str]:
         """
         Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         """
@@ -10212,9 +10643,9 @@ class GetMysqlDbSystemsDbSystemBackupPolicyPitrPolicyResult(dict):
 class GetMysqlDbSystemsDbSystemChannelResult(dict):
     def __init__(__self__, *,
                  compartment_id: str,
-                 defined_tags: Mapping[str, Any],
+                 defined_tags: Mapping[str, str],
                  display_name: str,
-                 freeform_tags: Mapping[str, Any],
+                 freeform_tags: Mapping[str, str],
                  id: str,
                  is_enabled: bool,
                  lifecycle_details: str,
@@ -10225,9 +10656,9 @@ class GetMysqlDbSystemsDbSystemChannelResult(dict):
                  time_updated: str):
         """
         :param str compartment_id: The compartment [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
-        :param Mapping[str, Any] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
+        :param Mapping[str, str] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         :param str display_name: A filter to return only the resource matching the given display name exactly.
-        :param Mapping[str, Any] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
+        :param Mapping[str, str] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         :param str id: The OCID of the DB System.
         :param bool is_enabled: Whether the Channel has been enabled by the user.
         :param str lifecycle_details: Additional information about the current lifecycleState.
@@ -10260,7 +10691,7 @@ class GetMysqlDbSystemsDbSystemChannelResult(dict):
 
     @property
     @pulumi.getter(name="definedTags")
-    def defined_tags(self) -> Mapping[str, Any]:
+    def defined_tags(self) -> Mapping[str, str]:
         """
         Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         """
@@ -10276,7 +10707,7 @@ class GetMysqlDbSystemsDbSystemChannelResult(dict):
 
     @property
     @pulumi.getter(name="freeformTags")
-    def freeform_tags(self) -> Mapping[str, Any]:
+    def freeform_tags(self) -> Mapping[str, str]:
         """
         Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         """
@@ -10653,6 +11084,68 @@ class GetMysqlDbSystemsDbSystemCurrentPlacementResult(dict):
         return pulumi.get(self, "fault_domain")
 
 
+@pulumi.output_type
+class GetMysqlDbSystemsDbSystemDataStorageResult(dict):
+    def __init__(__self__, *,
+                 allocated_storage_size_in_gbs: int,
+                 data_storage_size_in_gb: int,
+                 data_storage_size_limit_in_gbs: int,
+                 is_auto_expand_storage_enabled: bool,
+                 max_storage_size_in_gbs: int):
+        """
+        :param int allocated_storage_size_in_gbs: The actual allocated storage size for the DB System. This may be higher than dataStorageSizeInGBs if an automatic storage expansion has occurred.
+        :param int data_storage_size_in_gb: DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
+        :param int data_storage_size_limit_in_gbs: The absolute limit the DB System's storage size may ever expand to, either manually or automatically. This limit is based based on the initial dataStorageSizeInGBs when the DB System was first created. Both dataStorageSizeInGBs and maxDataStorageSizeInGBs can not exceed this value.
+        :param bool is_auto_expand_storage_enabled: Enable/disable automatic storage expansion. When set to true, the DB System will automatically add storage incrementally up to the value specified in maxStorageSizeInGBs.
+        :param int max_storage_size_in_gbs: Maximum storage size this DB System can expand to. When isAutoExpandStorageEnabled is set to true, the DB System will add storage incrementally up to this value.
+        """
+        pulumi.set(__self__, "allocated_storage_size_in_gbs", allocated_storage_size_in_gbs)
+        pulumi.set(__self__, "data_storage_size_in_gb", data_storage_size_in_gb)
+        pulumi.set(__self__, "data_storage_size_limit_in_gbs", data_storage_size_limit_in_gbs)
+        pulumi.set(__self__, "is_auto_expand_storage_enabled", is_auto_expand_storage_enabled)
+        pulumi.set(__self__, "max_storage_size_in_gbs", max_storage_size_in_gbs)
+
+    @property
+    @pulumi.getter(name="allocatedStorageSizeInGbs")
+    def allocated_storage_size_in_gbs(self) -> int:
+        """
+        The actual allocated storage size for the DB System. This may be higher than dataStorageSizeInGBs if an automatic storage expansion has occurred.
+        """
+        return pulumi.get(self, "allocated_storage_size_in_gbs")
+
+    @property
+    @pulumi.getter(name="dataStorageSizeInGb")
+    def data_storage_size_in_gb(self) -> int:
+        """
+        DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
+        """
+        return pulumi.get(self, "data_storage_size_in_gb")
+
+    @property
+    @pulumi.getter(name="dataStorageSizeLimitInGbs")
+    def data_storage_size_limit_in_gbs(self) -> int:
+        """
+        The absolute limit the DB System's storage size may ever expand to, either manually or automatically. This limit is based based on the initial dataStorageSizeInGBs when the DB System was first created. Both dataStorageSizeInGBs and maxDataStorageSizeInGBs can not exceed this value.
+        """
+        return pulumi.get(self, "data_storage_size_limit_in_gbs")
+
+    @property
+    @pulumi.getter(name="isAutoExpandStorageEnabled")
+    def is_auto_expand_storage_enabled(self) -> bool:
+        """
+        Enable/disable automatic storage expansion. When set to true, the DB System will automatically add storage incrementally up to the value specified in maxStorageSizeInGBs.
+        """
+        return pulumi.get(self, "is_auto_expand_storage_enabled")
+
+    @property
+    @pulumi.getter(name="maxStorageSizeInGbs")
+    def max_storage_size_in_gbs(self) -> int:
+        """
+        Maximum storage size this DB System can expand to. When isAutoExpandStorageEnabled is set to true, the DB System will add storage incrementally up to this value.
+        """
+        return pulumi.get(self, "max_storage_size_in_gbs")
+
+
 @pulumi.output_type
 class GetMysqlDbSystemsDbSystemDeletionPolicyResult(dict):
     def __init__(__self__, *,
@@ -11221,11 +11714,11 @@ class GetReplicasReplicaResult(dict):
                  compartment_id: str,
                  configuration_id: str,
                  db_system_id: str,
-                 defined_tags: Mapping[str, Any],
+                 defined_tags: Mapping[str, str],
                  description: str,
                  display_name: str,
                  fault_domain: str,
-                 freeform_tags: Mapping[str, Any],
+                 freeform_tags: Mapping[str, str],
                  id: str,
                  ip_address: str,
                  is_delete_protected: bool,
@@ -11244,11 +11737,11 @@ class GetReplicasReplicaResult(dict):
         :param str compartment_id: The compartment [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
         :param str configuration_id: The requested Configuration instance.
         :param str db_system_id: The DB System [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
-        :param Mapping[str, Any] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
+        :param Mapping[str, str] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         :param str description: User provided description of the read replica.
         :param str display_name: A filter to return only the resource matching the given display name exactly.
         :param str fault_domain: The name of the Fault Domain the read replica is located in.
-        :param Mapping[str, Any] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
+        :param Mapping[str, str] freeform_tags: Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         :param str id: The OCID of the read replica.
         :param str ip_address: The IP address the read replica is configured to listen on.
         :param bool is_delete_protected: Specifies whether the read replica can be deleted. Set to true to prevent deletion, false (default) to allow. Note that if a read replica is delete protected it also prevents the entire DB System from being deleted. If the DB System is delete protected, read replicas can still be deleted individually if they are not delete  protected themselves.
@@ -11320,7 +11813,7 @@ class GetReplicasReplicaResult(dict):
 
     @property
     @pulumi.getter(name="definedTags")
-    def defined_tags(self) -> Mapping[str, Any]:
+    def defined_tags(self) -> Mapping[str, str]:
         """
         Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         """
@@ -11352,7 +11845,7 @@ class GetReplicasReplicaResult(dict):
 
     @property
     @pulumi.getter(name="freeformTags")
-    def freeform_tags(self) -> Mapping[str, Any]:
+    def freeform_tags(self) -> Mapping[str, str]:
         """
         Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         """