pulumi-oci 3.10.0a1760684486__py3-none-any.whl → 3.10.0a1762316217__py3-none-any.whl

pulumi_oci/mysql/outputs.py

@@ -855,6 +855,8 @@ class MysqlBackupDbSystemSnapshot(dict):
             suggest = "read_endpoints"
         elif key == "secureConnections":
             suggest = "secure_connections"
+        elif key == "securityAttributes":
+            suggest = "security_attributes"
         elif key == "shapeName":
             suggest = "shape_name"
         elif key == "subnetId":
@@ -902,6 +904,7 @@ class MysqlBackupDbSystemSnapshot(dict):
                  region: Optional[_builtins.str] = None,
                  rests: Optional[Sequence['outputs.MysqlBackupDbSystemSnapshotRest']] = None,
                  secure_connections: Optional[Sequence['outputs.MysqlBackupDbSystemSnapshotSecureConnection']] = None,
+                 security_attributes: Optional[Mapping[str, _builtins.str]] = None,
                  shape_name: Optional[_builtins.str] = None,
                  subnet_id: Optional[_builtins.str] = None):
         """
@@ -935,6 +938,7 @@ class MysqlBackupDbSystemSnapshot(dict):
         :param _builtins.str region: The region identifier of the region where the DB system exists. For more information, please see [Regions and Availability Domains](https://docs.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm).
         :param Sequence['MysqlBackupDbSystemSnapshotRestArgs'] rests: REST configuration details.
         :param Sequence['MysqlBackupDbSystemSnapshotSecureConnectionArgs'] secure_connections: Secure connection configuration details.
+        :param Mapping[str, _builtins.str] security_attributes: Security Attributes for this resource. Each key is predefined and scoped to a namespace. For more information, see [ZPR Artifacts](https://docs.oracle.com/en-us/iaas/Content/zero-trust-packet-routing/zpr-artifacts.htm). Example: `{"Oracle-ZPR": {"MaxEgressCount": {"value": "42", "mode": "audit"}}}`
         :param _builtins.str shape_name: The shape of the DB System instance used for backup.
         :param _builtins.str subnet_id: The OCID of the subnet the DB System is associated with.
         """
@@ -998,6 +1002,8 @@ class MysqlBackupDbSystemSnapshot(dict):
             pulumi.set(__self__, "rests", rests)
         if secure_connections is not None:
             pulumi.set(__self__, "secure_connections", secure_connections)
+        if security_attributes is not None:
+            pulumi.set(__self__, "security_attributes", security_attributes)
         if shape_name is not None:
             pulumi.set(__self__, "shape_name", shape_name)
         if subnet_id is not None:
@@ -1243,6 +1249,14 @@ class MysqlBackupDbSystemSnapshot(dict):
         """
         return pulumi.get(self, "secure_connections")
 
+    @_builtins.property
+    @pulumi.getter(name="securityAttributes")
+    def security_attributes(self) -> Optional[Mapping[str, _builtins.str]]:
+        """
+        Security Attributes for this resource. Each key is predefined and scoped to a namespace. For more information, see [ZPR Artifacts](https://docs.oracle.com/en-us/iaas/Content/zero-trust-packet-routing/zpr-artifacts.htm). Example: `{"Oracle-ZPR": {"MaxEgressCount": {"value": "42", "mode": "audit"}}}`
+        """
+        return pulumi.get(self, "security_attributes")
+
     @_builtins.property
     @pulumi.getter(name="shapeName")
     def shape_name(self) -> Optional[_builtins.str]:
@@ -1831,7 +1845,17 @@ class MysqlBackupDbSystemSnapshotMaintenance(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "windowStartTime":
+        if key == "maintenanceScheduleType":
+            suggest = "maintenance_schedule_type"
+        elif key == "targetVersion":
+            suggest = "target_version"
+        elif key == "timeScheduled":
+            suggest = "time_scheduled"
+        elif key == "versionPreference":
+            suggest = "version_preference"
+        elif key == "versionTrackPreference":
+            suggest = "version_track_preference"
+        elif key == "windowStartTime":
             suggest = "window_start_time"
 
         if suggest:
@@ -1846,13 +1870,73 @@ class MysqlBackupDbSystemSnapshotMaintenance(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 maintenance_schedule_type: Optional[_builtins.str] = None,
+                 target_version: Optional[_builtins.str] = None,
+                 time_scheduled: Optional[_builtins.str] = None,
+                 version_preference: Optional[_builtins.str] = None,
+                 version_track_preference: Optional[_builtins.str] = None,
                  window_start_time: Optional[_builtins.str] = None):
         """
+        :param _builtins.str maintenance_schedule_type: The maintenance schedule type of the DB system. EARLY:   Maintenance schedule follows a cycle where upgrades are performed when versions become deprecated. REGULAR: Maintenance schedule follows the normal cycle where upgrades are performed when versions become unavailable.
+        :param _builtins.str target_version: The version that is expected to be targeted during the next scheduled maintenance run.
+        :param _builtins.str time_scheduled: The time the scheduled maintenance is expected to start, as described by [RFC 3339](https://tools.ietf.org/rfc/rfc3339).
+        :param _builtins.str version_preference: The preferred version to target when performing an automatic MySQL upgrade.
+        :param _builtins.str version_track_preference: The preferred version track to target when performing an automatic MySQL upgrade. LONG_TERM_SUPPORT: No MySQL database behavior changes. INNOVATION:        Provides access to the latest features and all bug fixes. FOLLOW:            Follows the track of the current MySQL version.
         :param _builtins.str window_start_time: The start time of the maintenance window.
         """
+        if maintenance_schedule_type is not None:
+            pulumi.set(__self__, "maintenance_schedule_type", maintenance_schedule_type)
+        if target_version is not None:
+            pulumi.set(__self__, "target_version", target_version)
+        if time_scheduled is not None:
+            pulumi.set(__self__, "time_scheduled", time_scheduled)
+        if version_preference is not None:
+            pulumi.set(__self__, "version_preference", version_preference)
+        if version_track_preference is not None:
+            pulumi.set(__self__, "version_track_preference", version_track_preference)
         if window_start_time is not None:
             pulumi.set(__self__, "window_start_time", window_start_time)
 
+    @_builtins.property
+    @pulumi.getter(name="maintenanceScheduleType")
+    def maintenance_schedule_type(self) -> Optional[_builtins.str]:
+        """
+        The maintenance schedule type of the DB system. EARLY:   Maintenance schedule follows a cycle where upgrades are performed when versions become deprecated. REGULAR: Maintenance schedule follows the normal cycle where upgrades are performed when versions become unavailable.
+        """
+        return pulumi.get(self, "maintenance_schedule_type")
+
+    @_builtins.property
+    @pulumi.getter(name="targetVersion")
+    def target_version(self) -> Optional[_builtins.str]:
+        """
+        The version that is expected to be targeted during the next scheduled maintenance run.
+        """
+        return pulumi.get(self, "target_version")
+
+    @_builtins.property
+    @pulumi.getter(name="timeScheduled")
+    def time_scheduled(self) -> Optional[_builtins.str]:
+        """
+        The time the scheduled maintenance is expected to start, as described by [RFC 3339](https://tools.ietf.org/rfc/rfc3339).
+        """
+        return pulumi.get(self, "time_scheduled")
+
+    @_builtins.property
+    @pulumi.getter(name="versionPreference")
+    def version_preference(self) -> Optional[_builtins.str]:
+        """
+        The preferred version to target when performing an automatic MySQL upgrade.
+        """
+        return pulumi.get(self, "version_preference")
+
+    @_builtins.property
+    @pulumi.getter(name="versionTrackPreference")
+    def version_track_preference(self) -> Optional[_builtins.str]:
+        """
+        The preferred version track to target when performing an automatic MySQL upgrade. LONG_TERM_SUPPORT: No MySQL database behavior changes. INNOVATION:        Provides access to the latest features and all bug fixes. FOLLOW:            Follows the track of the current MySQL version.
+        """
+        return pulumi.get(self, "version_track_preference")
+
     @_builtins.property
     @pulumi.getter(name="windowStartTime")
     def window_start_time(self) -> Optional[_builtins.str]:
@@ -5697,6 +5781,16 @@ class MysqlDbSystemMaintenance(dict):
         suggest = None
         if key == "windowStartTime":
             suggest = "window_start_time"
+        elif key == "maintenanceScheduleType":
+            suggest = "maintenance_schedule_type"
+        elif key == "targetVersion":
+            suggest = "target_version"
+        elif key == "timeScheduled":
+            suggest = "time_scheduled"
+        elif key == "versionPreference":
+            suggest = "version_preference"
+        elif key == "versionTrackPreference":
+            suggest = "version_track_preference"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in MysqlDbSystemMaintenance. Access the value via the '{suggest}' property getter instead.")
@@ -5710,7 +5804,12 @@ class MysqlDbSystemMaintenance(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 window_start_time: _builtins.str):
+                 window_start_time: _builtins.str,
+                 maintenance_schedule_type: Optional[_builtins.str] = None,
+                 target_version: Optional[_builtins.str] = None,
+                 time_scheduled: Optional[_builtins.str] = None,
+                 version_preference: Optional[_builtins.str] = None,
+                 version_track_preference: Optional[_builtins.str] = None):
         """
         :param _builtins.str window_start_time: (Updatable) The start of the 2 hour maintenance window.
                
@@ -5721,8 +5820,25 @@ class MysqlDbSystemMaintenance(dict):
                "{time-of-day}" is the "Time" portion of an RFC3339-formatted timestamp. Any second or sub-second time data will be truncated to zero.
                
                If you set the read replica maintenance window to "" or if not specified, the read replica is set same as the DB system maintenance window.
+        :param _builtins.str maintenance_schedule_type: (Updatable) The maintenance schedule type of the DB system. Defaults to REGULAR. EARLY:   Maintenance schedule follows a cycle where upgrades are performed when versions become deprecated. REGULAR: Maintenance schedule follows the normal cycle where upgrades are performed when versions become unavailable.
+        :param _builtins.str target_version: The version that is expected to be targeted during the next scheduled maintenance run.
+        :param _builtins.str time_scheduled: The time the scheduled maintenance is expected to start, as described by [RFC 3339](https://tools.ietf.org/rfc/rfc3339).
+        :param _builtins.str version_preference: (Updatable) The preferred version to target when performing an automatic MySQL upgrade. Defaults to OLDEST.
+               
+               OLDEST: Choose the oldest available MySQL version based on the current version of the DB System. SECOND_NEWEST: Choose the MySQL version before the newest for auto-upgrade. NEWEST: Choose the latest and greatest MySQL version available for auto-upgrade.
+        :param _builtins.str version_track_preference: (Updatable) The preferred version track to target when performing an automatic MySQL upgrade. Defaults to FOLLOW. LONG_TERM_SUPPORT: No MySQL database behavior changes. INNOVATION:        Provides access to the latest features and all bug fixes. FOLLOW:            Follows the track of the current MySQL version.
         """
         pulumi.set(__self__, "window_start_time", window_start_time)
+        if maintenance_schedule_type is not None:
+            pulumi.set(__self__, "maintenance_schedule_type", maintenance_schedule_type)
+        if target_version is not None:
+            pulumi.set(__self__, "target_version", target_version)
+        if time_scheduled is not None:
+            pulumi.set(__self__, "time_scheduled", time_scheduled)
+        if version_preference is not None:
+            pulumi.set(__self__, "version_preference", version_preference)
+        if version_track_preference is not None:
+            pulumi.set(__self__, "version_track_preference", version_track_preference)
 
     @_builtins.property
     @pulumi.getter(name="windowStartTime")
@@ -5740,6 +5856,48 @@ class MysqlDbSystemMaintenance(dict):
         """
         return pulumi.get(self, "window_start_time")
 
+    @_builtins.property
+    @pulumi.getter(name="maintenanceScheduleType")
+    def maintenance_schedule_type(self) -> Optional[_builtins.str]:
+        """
+        (Updatable) The maintenance schedule type of the DB system. Defaults to REGULAR. EARLY:   Maintenance schedule follows a cycle where upgrades are performed when versions become deprecated. REGULAR: Maintenance schedule follows the normal cycle where upgrades are performed when versions become unavailable.
+        """
+        return pulumi.get(self, "maintenance_schedule_type")
+
+    @_builtins.property
+    @pulumi.getter(name="targetVersion")
+    def target_version(self) -> Optional[_builtins.str]:
+        """
+        The version that is expected to be targeted during the next scheduled maintenance run.
+        """
+        return pulumi.get(self, "target_version")
+
+    @_builtins.property
+    @pulumi.getter(name="timeScheduled")
+    def time_scheduled(self) -> Optional[_builtins.str]:
+        """
+        The time the scheduled maintenance is expected to start, as described by [RFC 3339](https://tools.ietf.org/rfc/rfc3339).
+        """
+        return pulumi.get(self, "time_scheduled")
+
+    @_builtins.property
+    @pulumi.getter(name="versionPreference")
+    def version_preference(self) -> Optional[_builtins.str]:
+        """
+        (Updatable) The preferred version to target when performing an automatic MySQL upgrade. Defaults to OLDEST.
+
+        OLDEST: Choose the oldest available MySQL version based on the current version of the DB System. SECOND_NEWEST: Choose the MySQL version before the newest for auto-upgrade. NEWEST: Choose the latest and greatest MySQL version available for auto-upgrade.
+        """
+        return pulumi.get(self, "version_preference")
+
+    @_builtins.property
+    @pulumi.getter(name="versionTrackPreference")
+    def version_track_preference(self) -> Optional[_builtins.str]:
+        """
+        (Updatable) The preferred version track to target when performing an automatic MySQL upgrade. Defaults to FOLLOW. LONG_TERM_SUPPORT: No MySQL database behavior changes. INNOVATION:        Provides access to the latest features and all bug fixes. FOLLOW:            Follows the track of the current MySQL version.
+        """
+        return pulumi.get(self, "version_track_preference")
+
 
 @pulumi.output_type
 class MysqlDbSystemPointInTimeRecoveryDetail(dict):
@@ -6108,6 +6266,8 @@ class ReplicaReplicaOverrides(dict):
             suggest = "mysql_version"
         elif key == "nsgIds":
             suggest = "nsg_ids"
+        elif key == "securityAttributes":
+            suggest = "security_attributes"
         elif key == "shapeName":
             suggest = "shape_name"
 
@@ -6126,11 +6286,13 @@ class ReplicaReplicaOverrides(dict):
                  configuration_id: Optional[_builtins.str] = None,
                  mysql_version: Optional[_builtins.str] = None,
                  nsg_ids: Optional[Sequence[_builtins.str]] = None,
+                 security_attributes: Optional[Mapping[str, _builtins.str]] = None,
                  shape_name: Optional[_builtins.str] = None):
         """
         :param _builtins.str configuration_id: (Updatable) The OCID of the Configuration to be used by the read replica.
         :param _builtins.str mysql_version: (Updatable) The MySQL version to be used by the read replica.
         :param Sequence[_builtins.str] nsg_ids: (Updatable) Network Security Group OCIDs used for the VNIC attachment.
+        :param Mapping[str, _builtins.str] security_attributes: (Updatable) Security Attributes for this resource. Each key is predefined and scoped to a namespace. For more information, see [ZPR Artifacts](https://docs.oracle.com/en-us/iaas/Content/zero-trust-packet-routing/zpr-artifacts.htm). Example: `{"Oracle-ZPR": {"MaxEgressCount": {"value": "42", "mode": "audit"}}}`
         :param _builtins.str shape_name: (Updatable) The shape to be used by the read replica. The shape determines the resources allocated:  CPU cores and memory for VM shapes, CPU cores, memory and storage for non-VM (bare metal) shapes.  To get a list of shapes, use the [ListShapes](https://docs.cloud.oracle.com/iaas/api/#/en/mysql/20190415/ShapeSummary/ListShapes) operation. 
                
                
@@ -6143,6 +6305,8 @@ class ReplicaReplicaOverrides(dict):
             pulumi.set(__self__, "mysql_version", mysql_version)
         if nsg_ids is not None:
             pulumi.set(__self__, "nsg_ids", nsg_ids)
+        if security_attributes is not None:
+            pulumi.set(__self__, "security_attributes", security_attributes)
         if shape_name is not None:
             pulumi.set(__self__, "shape_name", shape_name)
 
@@ -6170,6 +6334,14 @@ class ReplicaReplicaOverrides(dict):
         """
         return pulumi.get(self, "nsg_ids")
 
+    @_builtins.property
+    @pulumi.getter(name="securityAttributes")
+    def security_attributes(self) -> Optional[Mapping[str, _builtins.str]]:
+        """
+        (Updatable) Security Attributes for this resource. Each key is predefined and scoped to a namespace. For more information, see [ZPR Artifacts](https://docs.oracle.com/en-us/iaas/Content/zero-trust-packet-routing/zpr-artifacts.htm). Example: `{"Oracle-ZPR": {"MaxEgressCount": {"value": "42", "mode": "audit"}}}`
+        """
+        return pulumi.get(self, "security_attributes")
+
     @_builtins.property
     @pulumi.getter(name="shapeName")
     def shape_name(self) -> Optional[_builtins.str]:
@@ -7175,6 +7347,7 @@ class GetMysqlBackupDbSystemSnapshotResult(dict):
                  region: _builtins.str,
                  rests: Sequence['outputs.GetMysqlBackupDbSystemSnapshotRestResult'],
                  secure_connections: Sequence['outputs.GetMysqlBackupDbSystemSnapshotSecureConnectionResult'],
+                 security_attributes: Mapping[str, _builtins.str],
                  shape_name: _builtins.str,
                  subnet_id: _builtins.str):
         """
@@ -7208,6 +7381,7 @@ class GetMysqlBackupDbSystemSnapshotResult(dict):
         :param _builtins.str region: The region identifier of the region where the DB system exists. For more information, please see [Regions and Availability Domains](https://docs.oracle.com/en-us/iaas/Content/General/Concepts/regions.htm).
         :param Sequence['GetMysqlBackupDbSystemSnapshotRestArgs'] rests: REST configuration details.
         :param Sequence['GetMysqlBackupDbSystemSnapshotSecureConnectionArgs'] secure_connections: Secure connection configuration details.
+        :param Mapping[str, _builtins.str] security_attributes: Security Attributes for this resource. Each key is predefined and scoped to a namespace. For more information, see [ZPR Artifacts](https://docs.oracle.com/en-us/iaas/Content/zero-trust-packet-routing/zpr-artifacts.htm). Example: `{"Oracle-ZPR": {"MaxEgressCount": {"value": "42", "mode": "audit"}}}`
         :param _builtins.str shape_name: The shape of the DB System instance used for backup.
         :param _builtins.str subnet_id: The OCID of the subnet the DB System is associated with.
         """
@@ -7241,6 +7415,7 @@ class GetMysqlBackupDbSystemSnapshotResult(dict):
         pulumi.set(__self__, "region", region)
         pulumi.set(__self__, "rests", rests)
         pulumi.set(__self__, "secure_connections", secure_connections)
+        pulumi.set(__self__, "security_attributes", security_attributes)
         pulumi.set(__self__, "shape_name", shape_name)
         pulumi.set(__self__, "subnet_id", subnet_id)
 
@@ -7484,6 +7659,14 @@ class GetMysqlBackupDbSystemSnapshotResult(dict):
         """
         return pulumi.get(self, "secure_connections")
 
+    @_builtins.property
+    @pulumi.getter(name="securityAttributes")
+    def security_attributes(self) -> Mapping[str, _builtins.str]:
+        """
+        Security Attributes for this resource. Each key is predefined and scoped to a namespace. For more information, see [ZPR Artifacts](https://docs.oracle.com/en-us/iaas/Content/zero-trust-packet-routing/zpr-artifacts.htm). Example: `{"Oracle-ZPR": {"MaxEgressCount": {"value": "42", "mode": "audit"}}}`
+        """
+        return pulumi.get(self, "security_attributes")
+
     @_builtins.property
     @pulumi.getter(name="shapeName")
     def shape_name(self) -> _builtins.str:
@@ -7883,12 +8066,67 @@ class GetMysqlBackupDbSystemSnapshotEndpointResult(dict):
 @pulumi.output_type
 class GetMysqlBackupDbSystemSnapshotMaintenanceResult(dict):
     def __init__(__self__, *,
+                 maintenance_schedule_type: _builtins.str,
+                 target_version: _builtins.str,
+                 time_scheduled: _builtins.str,
+                 version_preference: _builtins.str,
+                 version_track_preference: _builtins.str,
                  window_start_time: _builtins.str):
         """
+        :param _builtins.str maintenance_schedule_type: The maintenance schedule type of the DB system. EARLY:   Maintenance schedule follows a cycle where upgrades are performed when versions become deprecated. REGULAR: Maintenance schedule follows the normal cycle where upgrades are performed when versions become unavailable.
+        :param _builtins.str target_version: The version that is expected to be targeted during the next scheduled maintenance run.
+        :param _builtins.str time_scheduled: The time the scheduled maintenance is expected to start, as described by [RFC 3339](https://tools.ietf.org/rfc/rfc3339).
+        :param _builtins.str version_preference: The preferred version to target when performing an automatic MySQL upgrade.
+        :param _builtins.str version_track_preference: The preferred version track to target when performing an automatic MySQL upgrade. LONG_TERM_SUPPORT: No MySQL database behavior changes. INNOVATION:        Provides access to the latest features and all bug fixes. FOLLOW:            Follows the track of the current MySQL version.
         :param _builtins.str window_start_time: The start time of the maintenance window.
         """
+        pulumi.set(__self__, "maintenance_schedule_type", maintenance_schedule_type)
+        pulumi.set(__self__, "target_version", target_version)
+        pulumi.set(__self__, "time_scheduled", time_scheduled)
+        pulumi.set(__self__, "version_preference", version_preference)
+        pulumi.set(__self__, "version_track_preference", version_track_preference)
         pulumi.set(__self__, "window_start_time", window_start_time)
 
+    @_builtins.property
+    @pulumi.getter(name="maintenanceScheduleType")
+    def maintenance_schedule_type(self) -> _builtins.str:
+        """
+        The maintenance schedule type of the DB system. EARLY:   Maintenance schedule follows a cycle where upgrades are performed when versions become deprecated. REGULAR: Maintenance schedule follows the normal cycle where upgrades are performed when versions become unavailable.
+        """
+        return pulumi.get(self, "maintenance_schedule_type")
+
+    @_builtins.property
+    @pulumi.getter(name="targetVersion")
+    def target_version(self) -> _builtins.str:
+        """
+        The version that is expected to be targeted during the next scheduled maintenance run.
+        """
+        return pulumi.get(self, "target_version")
+
+    @_builtins.property
+    @pulumi.getter(name="timeScheduled")
+    def time_scheduled(self) -> _builtins.str:
+        """
+        The time the scheduled maintenance is expected to start, as described by [RFC 3339](https://tools.ietf.org/rfc/rfc3339).
+        """
+        return pulumi.get(self, "time_scheduled")
+
+    @_builtins.property
+    @pulumi.getter(name="versionPreference")
+    def version_preference(self) -> _builtins.str:
+        """
+        The preferred version to target when performing an automatic MySQL upgrade.
+        """
+        return pulumi.get(self, "version_preference")
+
+    @_builtins.property
+    @pulumi.getter(name="versionTrackPreference")
+    def version_track_preference(self) -> _builtins.str:
+        """
+        The preferred version track to target when performing an automatic MySQL upgrade. LONG_TERM_SUPPORT: No MySQL database behavior changes. INNOVATION:        Provides access to the latest features and all bug fixes. FOLLOW:            Follows the track of the current MySQL version.
+        """
+        return pulumi.get(self, "version_track_preference")
+
     @_builtins.property
     @pulumi.getter(name="windowStartTime")
     def window_start_time(self) -> _builtins.str:
@@ -12325,12 +12563,67 @@ class GetMysqlDbSystemHeatWaveClusterResult(dict):
 @pulumi.output_type
 class GetMysqlDbSystemMaintenanceResult(dict):
     def __init__(__self__, *,
+                 maintenance_schedule_type: _builtins.str,
+                 target_version: _builtins.str,
+                 time_scheduled: _builtins.str,
+                 version_preference: _builtins.str,
+                 version_track_preference: _builtins.str,
                  window_start_time: _builtins.str):
         """
+        :param _builtins.str maintenance_schedule_type: The maintenance schedule type of the DB system. EARLY:   Maintenance schedule follows a cycle where upgrades are performed when versions become deprecated. REGULAR: Maintenance schedule follows the normal cycle where upgrades are performed when versions become unavailable.
+        :param _builtins.str target_version: The version that is expected to be targeted during the next scheduled maintenance run.
+        :param _builtins.str time_scheduled: The time the scheduled maintenance is expected to start, as described by [RFC 3339](https://tools.ietf.org/rfc/rfc3339).
+        :param _builtins.str version_preference: The preferred version to target when performing an automatic MySQL upgrade.
+        :param _builtins.str version_track_preference: The preferred version track to target when performing an automatic MySQL upgrade. LONG_TERM_SUPPORT: No MySQL database behavior changes. INNOVATION:        Provides access to the latest features and all bug fixes. FOLLOW:            Follows the track of the current MySQL version.
         :param _builtins.str window_start_time: The start time of the maintenance window.
         """
+        pulumi.set(__self__, "maintenance_schedule_type", maintenance_schedule_type)
+        pulumi.set(__self__, "target_version", target_version)
+        pulumi.set(__self__, "time_scheduled", time_scheduled)
+        pulumi.set(__self__, "version_preference", version_preference)
+        pulumi.set(__self__, "version_track_preference", version_track_preference)
         pulumi.set(__self__, "window_start_time", window_start_time)
 
+    @_builtins.property
+    @pulumi.getter(name="maintenanceScheduleType")
+    def maintenance_schedule_type(self) -> _builtins.str:
+        """
+        The maintenance schedule type of the DB system. EARLY:   Maintenance schedule follows a cycle where upgrades are performed when versions become deprecated. REGULAR: Maintenance schedule follows the normal cycle where upgrades are performed when versions become unavailable.
+        """
+        return pulumi.get(self, "maintenance_schedule_type")
+
+    @_builtins.property
+    @pulumi.getter(name="targetVersion")
+    def target_version(self) -> _builtins.str:
+        """
+        The version that is expected to be targeted during the next scheduled maintenance run.
+        """
+        return pulumi.get(self, "target_version")
+
+    @_builtins.property
+    @pulumi.getter(name="timeScheduled")
+    def time_scheduled(self) -> _builtins.str:
+        """
+        The time the scheduled maintenance is expected to start, as described by [RFC 3339](https://tools.ietf.org/rfc/rfc3339).
+        """
+        return pulumi.get(self, "time_scheduled")
+
+    @_builtins.property
+    @pulumi.getter(name="versionPreference")
+    def version_preference(self) -> _builtins.str:
+        """
+        The preferred version to target when performing an automatic MySQL upgrade.
+        """
+        return pulumi.get(self, "version_preference")
+
+    @_builtins.property
+    @pulumi.getter(name="versionTrackPreference")
+    def version_track_preference(self) -> _builtins.str:
+        """
+        The preferred version track to target when performing an automatic MySQL upgrade. LONG_TERM_SUPPORT: No MySQL database behavior changes. INNOVATION:        Provides access to the latest features and all bug fixes. FOLLOW:            Follows the track of the current MySQL version.
+        """
+        return pulumi.get(self, "version_track_preference")
+
     @_builtins.property
     @pulumi.getter(name="windowStartTime")
     def window_start_time(self) -> _builtins.str:
@@ -12578,6 +12871,7 @@ class GetMysqlDbSystemsDbSystemResult(dict):
                  read_endpoints: Sequence['outputs.GetMysqlDbSystemsDbSystemReadEndpointResult'],
                  rests: Sequence['outputs.GetMysqlDbSystemsDbSystemRestResult'],
                  secure_connections: Sequence['outputs.GetMysqlDbSystemsDbSystemSecureConnectionResult'],
+                 security_attributes: Mapping[str, _builtins.str],
                  shape_name: _builtins.str,
                  shutdown_type: _builtins.str,
                  sources: Sequence['outputs.GetMysqlDbSystemsDbSystemSourceResult'],
@@ -12628,6 +12922,7 @@ class GetMysqlDbSystemsDbSystemResult(dict):
         :param Sequence['GetMysqlDbSystemsDbSystemReadEndpointArgs'] read_endpoints: The read endpoint of a DB System.
         :param Sequence['GetMysqlDbSystemsDbSystemRestArgs'] rests: REST configuration details.
         :param Sequence['GetMysqlDbSystemsDbSystemSecureConnectionArgs'] secure_connections: Secure connection configuration details.
+        :param Mapping[str, _builtins.str] security_attributes: Security Attributes for this resource. Each key is predefined and scoped to a namespace. For more information, see [ZPR Artifacts](https://docs.oracle.com/en-us/iaas/Content/zero-trust-packet-routing/zpr-artifacts.htm). Example: `{"Oracle-ZPR": {"MaxEgressCount": {"value": "42", "mode": "audit"}}}`
         :param _builtins.str shape_name: The shape of the primary instances of the DB System. The shape determines resources allocated to a DB System - CPU cores and memory for VM shapes; CPU cores, memory and storage for non-VM (or bare metal) shapes. To get a list of shapes, use (the [ListShapes](https://docs.cloud.oracle.com/iaas/api/#/en/mysql/20181021/ShapeSummary/ListShapes) operation.
         :param Sequence['GetMysqlDbSystemsDbSystemSourceArgs'] sources: Parameters detailing how to provision the initial data of the DB System.
         :param _builtins.str state: DbSystem Lifecycle State
@@ -12675,6 +12970,7 @@ class GetMysqlDbSystemsDbSystemResult(dict):
         pulumi.set(__self__, "read_endpoints", read_endpoints)
         pulumi.set(__self__, "rests", rests)
         pulumi.set(__self__, "secure_connections", secure_connections)
+        pulumi.set(__self__, "security_attributes", security_attributes)
         pulumi.set(__self__, "shape_name", shape_name)
         pulumi.set(__self__, "shutdown_type", shutdown_type)
         pulumi.set(__self__, "sources", sources)
@@ -12994,6 +13290,14 @@ class GetMysqlDbSystemsDbSystemResult(dict):
         """
         return pulumi.get(self, "secure_connections")
 
+    @_builtins.property
+    @pulumi.getter(name="securityAttributes")
+    def security_attributes(self) -> Mapping[str, _builtins.str]:
+        """
+        Security Attributes for this resource. Each key is predefined and scoped to a namespace. For more information, see [ZPR Artifacts](https://docs.oracle.com/en-us/iaas/Content/zero-trust-packet-routing/zpr-artifacts.htm). Example: `{"Oracle-ZPR": {"MaxEgressCount": {"value": "42", "mode": "audit"}}}`
+        """
+        return pulumi.get(self, "security_attributes")
+
     @_builtins.property
     @pulumi.getter(name="shapeName")
     def shape_name(self) -> _builtins.str:
@@ -13985,12 +14289,67 @@ class GetMysqlDbSystemsDbSystemHeatWaveClusterResult(dict):
 @pulumi.output_type
 class GetMysqlDbSystemsDbSystemMaintenanceResult(dict):
     def __init__(__self__, *,
+                 maintenance_schedule_type: _builtins.str,
+                 target_version: _builtins.str,
+                 time_scheduled: _builtins.str,
+                 version_preference: _builtins.str,
+                 version_track_preference: _builtins.str,
                  window_start_time: _builtins.str):
         """
+        :param _builtins.str maintenance_schedule_type: The maintenance schedule type of the DB system. EARLY:   Maintenance schedule follows a cycle where upgrades are performed when versions become deprecated. REGULAR: Maintenance schedule follows the normal cycle where upgrades are performed when versions become unavailable.
+        :param _builtins.str target_version: The version that is expected to be targeted during the next scheduled maintenance run.
+        :param _builtins.str time_scheduled: The time the scheduled maintenance is expected to start, as described by [RFC 3339](https://tools.ietf.org/rfc/rfc3339).
+        :param _builtins.str version_preference: The preferred version to target when performing an automatic MySQL upgrade.
+        :param _builtins.str version_track_preference: The preferred version track to target when performing an automatic MySQL upgrade. LONG_TERM_SUPPORT: No MySQL database behavior changes. INNOVATION:        Provides access to the latest features and all bug fixes. FOLLOW:            Follows the track of the current MySQL version.
         :param _builtins.str window_start_time: The start time of the maintenance window.
         """
+        pulumi.set(__self__, "maintenance_schedule_type", maintenance_schedule_type)
+        pulumi.set(__self__, "target_version", target_version)
+        pulumi.set(__self__, "time_scheduled", time_scheduled)
+        pulumi.set(__self__, "version_preference", version_preference)
+        pulumi.set(__self__, "version_track_preference", version_track_preference)
         pulumi.set(__self__, "window_start_time", window_start_time)
 
+    @_builtins.property
+    @pulumi.getter(name="maintenanceScheduleType")
+    def maintenance_schedule_type(self) -> _builtins.str:
+        """
+        The maintenance schedule type of the DB system. EARLY:   Maintenance schedule follows a cycle where upgrades are performed when versions become deprecated. REGULAR: Maintenance schedule follows the normal cycle where upgrades are performed when versions become unavailable.
+        """
+        return pulumi.get(self, "maintenance_schedule_type")
+
+    @_builtins.property
+    @pulumi.getter(name="targetVersion")
+    def target_version(self) -> _builtins.str:
+        """
+        The version that is expected to be targeted during the next scheduled maintenance run.
+        """
+        return pulumi.get(self, "target_version")
+
+    @_builtins.property
+    @pulumi.getter(name="timeScheduled")
+    def time_scheduled(self) -> _builtins.str:
+        """
+        The time the scheduled maintenance is expected to start, as described by [RFC 3339](https://tools.ietf.org/rfc/rfc3339).
+        """
+        return pulumi.get(self, "time_scheduled")
+
+    @_builtins.property
+    @pulumi.getter(name="versionPreference")
+    def version_preference(self) -> _builtins.str:
+        """
+        The preferred version to target when performing an automatic MySQL upgrade.
+        """
+        return pulumi.get(self, "version_preference")
+
+    @_builtins.property
+    @pulumi.getter(name="versionTrackPreference")
+    def version_track_preference(self) -> _builtins.str:
+        """
+        The preferred version track to target when performing an automatic MySQL upgrade. LONG_TERM_SUPPORT: No MySQL database behavior changes. INNOVATION:        Provides access to the latest features and all bug fixes. FOLLOW:            Follows the track of the current MySQL version.
+        """
+        return pulumi.get(self, "version_track_preference")
+
     @_builtins.property
     @pulumi.getter(name="windowStartTime")
     def window_start_time(self) -> _builtins.str:
@@ -14343,16 +14702,19 @@ class GetReplicaReplicaOverrideResult(dict):
                  configuration_id: _builtins.str,
                  mysql_version: _builtins.str,
                  nsg_ids: Sequence[_builtins.str],
+                 security_attributes: Mapping[str, _builtins.str],
                  shape_name: _builtins.str):
         """
         :param _builtins.str configuration_id: The OCID of the Configuration to be used by the read replica.
         :param _builtins.str mysql_version: The MySQL version to be used by the read replica.
         :param Sequence[_builtins.str] nsg_ids: Network Security Group OCIDs used for the VNIC attachment.
+        :param Mapping[str, _builtins.str] security_attributes: Security Attributes for this resource. Each key is predefined and scoped to a namespace. For more information, see [ZPR Artifacts](https://docs.oracle.com/en-us/iaas/Content/zero-trust-packet-routing/zpr-artifacts.htm). Example: `{"Oracle-ZPR": {"MaxEgressCount": {"value": "42", "mode": "audit"}}}`
         :param _builtins.str shape_name: The shape currently in use by the read replica. The shape determines the resources allocated:  CPU cores and memory for VM shapes, CPU cores, memory and storage for non-VM (bare metal) shapes.  To get a list of shapes, use the [ListShapes](https://docs.cloud.oracle.com/iaas/api/#/en/mysql/20190415/ShapeSummary/ListShapes) operation.
         """
         pulumi.set(__self__, "configuration_id", configuration_id)
         pulumi.set(__self__, "mysql_version", mysql_version)
         pulumi.set(__self__, "nsg_ids", nsg_ids)
+        pulumi.set(__self__, "security_attributes", security_attributes)
         pulumi.set(__self__, "shape_name", shape_name)
 
     @_builtins.property
@@ -14379,6 +14741,14 @@ class GetReplicaReplicaOverrideResult(dict):
         """
         return pulumi.get(self, "nsg_ids")
 
+    @_builtins.property
+    @pulumi.getter(name="securityAttributes")
+    def security_attributes(self) -> Mapping[str, _builtins.str]:
+        """
+        Security Attributes for this resource. Each key is predefined and scoped to a namespace. For more information, see [ZPR Artifacts](https://docs.oracle.com/en-us/iaas/Content/zero-trust-packet-routing/zpr-artifacts.htm). Example: `{"Oracle-ZPR": {"MaxEgressCount": {"value": "42", "mode": "audit"}}}`
+        """
+        return pulumi.get(self, "security_attributes")
+
     @_builtins.property
     @pulumi.getter(name="shapeName")
     def shape_name(self) -> _builtins.str:
@@ -14467,6 +14837,7 @@ class GetReplicasReplicaResult(dict):
                  port_x: _builtins.int,
                  replica_overrides: Sequence['outputs.GetReplicasReplicaReplicaOverrideResult'],
                  secure_connections: Sequence['outputs.GetReplicasReplicaSecureConnectionResult'],
+                 security_attributes: Mapping[str, _builtins.str],
                  shape_name: _builtins.str,
                  state: _builtins.str,
                  time_created: _builtins.str,
@@ -14492,6 +14863,7 @@ class GetReplicasReplicaResult(dict):
         :param _builtins.int port_x: The TCP network port on which X Plugin listens for connections. This is the X Plugin equivalent of port.
         :param Sequence['GetReplicasReplicaReplicaOverrideArgs'] replica_overrides: By default a read replica inherits the MySQL version, shape, and configuration of the source DB system.  If you want to override any of these, provide values in the properties, mysqlVersion, shapeName,  and configurationId. If you set a property value to "", then the value is inherited from its  source DB system.
         :param Sequence['GetReplicasReplicaSecureConnectionArgs'] secure_connections: Secure connection configuration details.
+        :param Mapping[str, _builtins.str] security_attributes: Security Attributes for this resource. Each key is predefined and scoped to a namespace. For more information, see [ZPR Artifacts](https://docs.oracle.com/en-us/iaas/Content/zero-trust-packet-routing/zpr-artifacts.htm). Example: `{"Oracle-ZPR": {"MaxEgressCount": {"value": "42", "mode": "audit"}}}`
         :param _builtins.str shape_name: The shape currently in use by the read replica. The shape determines the resources allocated:  CPU cores and memory for VM shapes, CPU cores, memory and storage for non-VM (bare metal) shapes.  To get a list of shapes, use the [ListShapes](https://docs.cloud.oracle.com/iaas/api/#/en/mysql/20190415/ShapeSummary/ListShapes) operation.
         :param _builtins.str state: The LifecycleState of the read replica.
         :param _builtins.str time_created: The date and time the read replica was created, as described by [RFC 3339](https://tools.ietf.org/rfc/rfc3339).
@@ -14517,6 +14889,7 @@ class GetReplicasReplicaResult(dict):
         pulumi.set(__self__, "port_x", port_x)
         pulumi.set(__self__, "replica_overrides", replica_overrides)
         pulumi.set(__self__, "secure_connections", secure_connections)
+        pulumi.set(__self__, "security_attributes", security_attributes)
         pulumi.set(__self__, "shape_name", shape_name)
         pulumi.set(__self__, "state", state)
         pulumi.set(__self__, "time_created", time_created)
@@ -14682,6 +15055,14 @@ class GetReplicasReplicaResult(dict):
         """
         return pulumi.get(self, "secure_connections")
 
+    @_builtins.property
+    @pulumi.getter(name="securityAttributes")
+    def security_attributes(self) -> Mapping[str, _builtins.str]:
+        """
+        Security Attributes for this resource. Each key is predefined and scoped to a namespace. For more information, see [ZPR Artifacts](https://docs.oracle.com/en-us/iaas/Content/zero-trust-packet-routing/zpr-artifacts.htm). Example: `{"Oracle-ZPR": {"MaxEgressCount": {"value": "42", "mode": "audit"}}}`
+        """
+        return pulumi.get(self, "security_attributes")
+
     @_builtins.property
     @pulumi.getter(name="shapeName")
     def shape_name(self) -> _builtins.str:
@@ -14750,16 +15131,19 @@ class GetReplicasReplicaReplicaOverrideResult(dict):
                  configuration_id: _builtins.str,
                  mysql_version: _builtins.str,
                  nsg_ids: Sequence[_builtins.str],
+                 security_attributes: Mapping[str, _builtins.str],
                  shape_name: _builtins.str):
         """
         :param _builtins.str configuration_id: The requested Configuration instance.
         :param _builtins.str mysql_version: The MySQL version to be used by the read replica.
         :param Sequence[_builtins.str] nsg_ids: Network Security Group OCIDs used for the VNIC attachment.
+        :param Mapping[str, _builtins.str] security_attributes: Security Attributes for this resource. Each key is predefined and scoped to a namespace. For more information, see [ZPR Artifacts](https://docs.oracle.com/en-us/iaas/Content/zero-trust-packet-routing/zpr-artifacts.htm). Example: `{"Oracle-ZPR": {"MaxEgressCount": {"value": "42", "mode": "audit"}}}`
         :param _builtins.str shape_name: The shape currently in use by the read replica. The shape determines the resources allocated:  CPU cores and memory for VM shapes, CPU cores, memory and storage for non-VM (bare metal) shapes.  To get a list of shapes, use the [ListShapes](https://docs.cloud.oracle.com/iaas/api/#/en/mysql/20190415/ShapeSummary/ListShapes) operation.
         """
         pulumi.set(__self__, "configuration_id", configuration_id)
         pulumi.set(__self__, "mysql_version", mysql_version)
         pulumi.set(__self__, "nsg_ids", nsg_ids)
+        pulumi.set(__self__, "security_attributes", security_attributes)
         pulumi.set(__self__, "shape_name", shape_name)
 
     @_builtins.property
@@ -14786,6 +15170,14 @@ class GetReplicasReplicaReplicaOverrideResult(dict):
         """
         return pulumi.get(self, "nsg_ids")
 
+    @_builtins.property
+    @pulumi.getter(name="securityAttributes")
+    def security_attributes(self) -> Mapping[str, _builtins.str]:
+        """
+        Security Attributes for this resource. Each key is predefined and scoped to a namespace. For more information, see [ZPR Artifacts](https://docs.oracle.com/en-us/iaas/Content/zero-trust-packet-routing/zpr-artifacts.htm). Example: `{"Oracle-ZPR": {"MaxEgressCount": {"value": "42", "mode": "audit"}}}`
+        """
+        return pulumi.get(self, "security_attributes")
+
     @_builtins.property
     @pulumi.getter(name="shapeName")
     def shape_name(self) -> _builtins.str: