pulumi-oci 1.11.0a1695829678__py3-none-any.whl → 1.12.0__py3-none-any.whl

pulumi_oci/mysql/_inputs.py

@@ -6,7 +6,7 @@ import copy
 import warnings
 import pulumi
 import pulumi.runtime
-from typing import Any, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
 from .. import _utilities
 
 __all__ = [
@@ -39,6 +39,7 @@ __all__ = [
     'MysqlDbSystemMaintenanceArgs',
     'MysqlDbSystemPointInTimeRecoveryDetailArgs',
     'MysqlDbSystemSourceArgs',
+    'ReplicaReplicaOverridesArgs',
     'GetChannelsFilterArgs',
     'GetMysqlBackupsFilterArgs',
     'GetMysqlConfigurationsFilterArgs',
@@ -69,17 +70,40 @@ class ChannelSourceArgs:
         :param pulumi.Input[int] port: (Updatable) The port the source MySQL instance listens on.
         :param pulumi.Input['ChannelSourceSslCaCertificateArgs'] ssl_ca_certificate: (Updatable) The CA certificate of the server used for VERIFY_IDENTITY and VERIFY_CA ssl modes.
         """
-        pulumi.set(__self__, "hostname", hostname)
-        pulumi.set(__self__, "password", password)
-        pulumi.set(__self__, "source_type", source_type)
-        pulumi.set(__self__, "ssl_mode", ssl_mode)
-        pulumi.set(__self__, "username", username)
+        ChannelSourceArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            hostname=hostname,
+            password=password,
+            source_type=source_type,
+            ssl_mode=ssl_mode,
+            username=username,
+            anonymous_transactions_handling=anonymous_transactions_handling,
+            port=port,
+            ssl_ca_certificate=ssl_ca_certificate,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             hostname: pulumi.Input[str],
+             password: pulumi.Input[str],
+             source_type: pulumi.Input[str],
+             ssl_mode: pulumi.Input[str],
+             username: pulumi.Input[str],
+             anonymous_transactions_handling: Optional[pulumi.Input['ChannelSourceAnonymousTransactionsHandlingArgs']] = None,
+             port: Optional[pulumi.Input[int]] = None,
+             ssl_ca_certificate: Optional[pulumi.Input['ChannelSourceSslCaCertificateArgs']] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
+        _setter("hostname", hostname)
+        _setter("password", password)
+        _setter("source_type", source_type)
+        _setter("ssl_mode", ssl_mode)
+        _setter("username", username)
         if anonymous_transactions_handling is not None:
-            pulumi.set(__self__, "anonymous_transactions_handling", anonymous_transactions_handling)
+            _setter("anonymous_transactions_handling", anonymous_transactions_handling)
         if port is not None:
-            pulumi.set(__self__, "port", port)
+            _setter("port", port)
         if ssl_ca_certificate is not None:
-            pulumi.set(__self__, "ssl_ca_certificate", ssl_ca_certificate)
+            _setter("ssl_ca_certificate", ssl_ca_certificate)
 
     @property
     @pulumi.getter
@@ -191,13 +215,28 @@ class ChannelSourceAnonymousTransactionsHandlingArgs:
         :param pulumi.Input[str] last_configured_log_offset: (Updatable) Specifies one of the coordinates (offset) at which the replica should begin reading the source's log. As this value specifies the point where replication starts from, it is only used once, when it starts. It is never used again, unless a new UpdateChannel operation modifies it.
         :param pulumi.Input[str] uuid: (Updatable) The UUID that is used as a prefix when generating transaction identifiers for anonymous transactions coming from the source. You can change the UUID later.
         """
-        pulumi.set(__self__, "policy", policy)
+        ChannelSourceAnonymousTransactionsHandlingArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            policy=policy,
+            last_configured_log_filename=last_configured_log_filename,
+            last_configured_log_offset=last_configured_log_offset,
+            uuid=uuid,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             policy: pulumi.Input[str],
+             last_configured_log_filename: Optional[pulumi.Input[str]] = None,
+             last_configured_log_offset: Optional[pulumi.Input[str]] = None,
+             uuid: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
+        _setter("policy", policy)
         if last_configured_log_filename is not None:
-            pulumi.set(__self__, "last_configured_log_filename", last_configured_log_filename)
+            _setter("last_configured_log_filename", last_configured_log_filename)
         if last_configured_log_offset is not None:
-            pulumi.set(__self__, "last_configured_log_offset", last_configured_log_offset)
+            _setter("last_configured_log_offset", last_configured_log_offset)
         if uuid is not None:
-            pulumi.set(__self__, "uuid", uuid)
+            _setter("uuid", uuid)
 
     @property
     @pulumi.getter
@@ -257,8 +296,19 @@ class ChannelSourceSslCaCertificateArgs:
         :param pulumi.Input[str] certificate_type: (Updatable) The type of CA certificate.
         :param pulumi.Input[str] contents: (Updatable) The string containing the CA certificate in PEM format.
         """
-        pulumi.set(__self__, "certificate_type", certificate_type)
-        pulumi.set(__self__, "contents", contents)
+        ChannelSourceSslCaCertificateArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            certificate_type=certificate_type,
+            contents=contents,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             certificate_type: pulumi.Input[str],
+             contents: pulumi.Input[str],
+             opts: Optional[pulumi.ResourceOptions]=None):
+        _setter("certificate_type", certificate_type)
+        _setter("contents", contents)
 
     @property
     @pulumi.getter(name="certificateType")
@@ -308,18 +358,39 @@ class ChannelTargetArgs:
         :param pulumi.Input[Sequence[pulumi.Input['ChannelTargetFilterArgs']]] filters: (Updatable) Replication filter rules to be applied at the DB System Channel target.
         :param pulumi.Input[str] tables_without_primary_key_handling: (Updatable) Specifies how a replication channel handles the creation and alteration of tables  that do not have a primary key. The default value is set to ALLOW.
         """
-        pulumi.set(__self__, "db_system_id", db_system_id)
-        pulumi.set(__self__, "target_type", target_type)
+        ChannelTargetArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            db_system_id=db_system_id,
+            target_type=target_type,
+            applier_username=applier_username,
+            channel_name=channel_name,
+            delay_in_seconds=delay_in_seconds,
+            filters=filters,
+            tables_without_primary_key_handling=tables_without_primary_key_handling,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             db_system_id: pulumi.Input[str],
+             target_type: pulumi.Input[str],
+             applier_username: Optional[pulumi.Input[str]] = None,
+             channel_name: Optional[pulumi.Input[str]] = None,
+             delay_in_seconds: Optional[pulumi.Input[int]] = None,
+             filters: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelTargetFilterArgs']]]] = None,
+             tables_without_primary_key_handling: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
+        _setter("db_system_id", db_system_id)
+        _setter("target_type", target_type)
         if applier_username is not None:
-            pulumi.set(__self__, "applier_username", applier_username)
+            _setter("applier_username", applier_username)
         if channel_name is not None:
-            pulumi.set(__self__, "channel_name", channel_name)
+            _setter("channel_name", channel_name)
         if delay_in_seconds is not None:
-            pulumi.set(__self__, "delay_in_seconds", delay_in_seconds)
+            _setter("delay_in_seconds", delay_in_seconds)
         if filters is not None:
-            pulumi.set(__self__, "filters", filters)
+            _setter("filters", filters)
         if tables_without_primary_key_handling is not None:
-            pulumi.set(__self__, "tables_without_primary_key_handling", tables_without_primary_key_handling)
+            _setter("tables_without_primary_key_handling", tables_without_primary_key_handling)
 
     @property
     @pulumi.getter(name="dbSystemId")
@@ -421,8 +492,19 @@ class ChannelTargetFilterArgs:
                For details on each type, see [Replication Filtering Rules](https://dev.mysql.com/doc/refman/8.0/en/replication-rules.html)
         :param pulumi.Input[str] value: (Updatable) The body of the filter rule. This can represent a database, a table, or a database pair (represented as "db1->db2"). For more information, see [Replication Filtering Rules](https://dev.mysql.com/doc/refman/8.0/en/replication-rules.html).
         """
-        pulumi.set(__self__, "type", type)
-        pulumi.set(__self__, "value", value)
+        ChannelTargetFilterArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            type=type,
+            value=value,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             type: pulumi.Input[str],
+             value: pulumi.Input[str],
+             opts: Optional[pulumi.ResourceOptions]=None):
+        _setter("type", type)
+        _setter("value", value)
 
     @property
     @pulumi.getter
@@ -467,14 +549,29 @@ class HeatWaveClusterClusterNodeArgs:
         :param pulumi.Input[str] time_created: The date and time the HeatWave cluster was created, as described by [RFC 3339](https://tools.ietf.org/rfc/rfc3339).
         :param pulumi.Input[str] time_updated: The time the HeatWave cluster was last updated, as described by [RFC 3339](https://tools.ietf.org/rfc/rfc3339).
         """
+        HeatWaveClusterClusterNodeArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            node_id=node_id,
+            state=state,
+            time_created=time_created,
+            time_updated=time_updated,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             node_id: Optional[pulumi.Input[str]] = None,
+             state: Optional[pulumi.Input[str]] = None,
+             time_created: Optional[pulumi.Input[str]] = None,
+             time_updated: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if node_id is not None:
-            pulumi.set(__self__, "node_id", node_id)
+            _setter("node_id", node_id)
         if state is not None:
-            pulumi.set(__self__, "state", state)
+            _setter("state", state)
         if time_created is not None:
-            pulumi.set(__self__, "time_created", time_created)
+            _setter("time_created", time_created)
         if time_updated is not None:
-            pulumi.set(__self__, "time_updated", time_updated)
+            _setter("time_updated", time_updated)
 
     @property
     @pulumi.getter(name="nodeId")
@@ -581,54 +678,109 @@ class MysqlBackupDbSystemSnapshotArgs:
         :param pulumi.Input[str] shape_name: The shape of the DB System instance used for backup.
         :param pulumi.Input[str] subnet_id: The OCID of the subnet the DB System is associated with.
         """
+        MysqlBackupDbSystemSnapshotArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            admin_username=admin_username,
+            availability_domain=availability_domain,
+            backup_policies=backup_policies,
+            compartment_id=compartment_id,
+            configuration_id=configuration_id,
+            crash_recovery=crash_recovery,
+            data_storage_size_in_gb=data_storage_size_in_gb,
+            defined_tags=defined_tags,
+            deletion_policies=deletion_policies,
+            description=description,
+            display_name=display_name,
+            endpoints=endpoints,
+            fault_domain=fault_domain,
+            freeform_tags=freeform_tags,
+            hostname_label=hostname_label,
+            id=id,
+            ip_address=ip_address,
+            is_highly_available=is_highly_available,
+            maintenances=maintenances,
+            mysql_version=mysql_version,
+            port=port,
+            port_x=port_x,
+            shape_name=shape_name,
+            subnet_id=subnet_id,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             admin_username: Optional[pulumi.Input[str]] = None,
+             availability_domain: Optional[pulumi.Input[str]] = None,
+             backup_policies: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotBackupPolicyArgs']]]] = None,
+             compartment_id: Optional[pulumi.Input[str]] = None,
+             configuration_id: Optional[pulumi.Input[str]] = None,
+             crash_recovery: Optional[pulumi.Input[str]] = None,
+             data_storage_size_in_gb: Optional[pulumi.Input[int]] = None,
+             defined_tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+             deletion_policies: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotDeletionPolicyArgs']]]] = None,
+             description: Optional[pulumi.Input[str]] = None,
+             display_name: Optional[pulumi.Input[str]] = None,
+             endpoints: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotEndpointArgs']]]] = None,
+             fault_domain: Optional[pulumi.Input[str]] = None,
+             freeform_tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+             hostname_label: Optional[pulumi.Input[str]] = None,
+             id: Optional[pulumi.Input[str]] = None,
+             ip_address: Optional[pulumi.Input[str]] = None,
+             is_highly_available: Optional[pulumi.Input[bool]] = None,
+             maintenances: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotMaintenanceArgs']]]] = None,
+             mysql_version: Optional[pulumi.Input[str]] = None,
+             port: Optional[pulumi.Input[int]] = None,
+             port_x: Optional[pulumi.Input[int]] = None,
+             shape_name: Optional[pulumi.Input[str]] = None,
+             subnet_id: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if admin_username is not None:
-            pulumi.set(__self__, "admin_username", admin_username)
+            _setter("admin_username", admin_username)
         if availability_domain is not None:
-            pulumi.set(__self__, "availability_domain", availability_domain)
+            _setter("availability_domain", availability_domain)
         if backup_policies is not None:
-            pulumi.set(__self__, "backup_policies", backup_policies)
+            _setter("backup_policies", backup_policies)
         if compartment_id is not None:
-            pulumi.set(__self__, "compartment_id", compartment_id)
+            _setter("compartment_id", compartment_id)
         if configuration_id is not None:
-            pulumi.set(__self__, "configuration_id", configuration_id)
+            _setter("configuration_id", configuration_id)
         if crash_recovery is not None:
-            pulumi.set(__self__, "crash_recovery", crash_recovery)
+            _setter("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)
+            _setter("data_storage_size_in_gb", data_storage_size_in_gb)
         if defined_tags is not None:
-            pulumi.set(__self__, "defined_tags", defined_tags)
+            _setter("defined_tags", defined_tags)
         if deletion_policies is not None:
-            pulumi.set(__self__, "deletion_policies", deletion_policies)
+            _setter("deletion_policies", deletion_policies)
         if description is not None:
-            pulumi.set(__self__, "description", description)
+            _setter("description", description)
         if display_name is not None:
-            pulumi.set(__self__, "display_name", display_name)
+            _setter("display_name", display_name)
         if endpoints is not None:
-            pulumi.set(__self__, "endpoints", endpoints)
+            _setter("endpoints", endpoints)
         if fault_domain is not None:
-            pulumi.set(__self__, "fault_domain", fault_domain)
+            _setter("fault_domain", fault_domain)
         if freeform_tags is not None:
-            pulumi.set(__self__, "freeform_tags", freeform_tags)
+            _setter("freeform_tags", freeform_tags)
         if hostname_label is not None:
-            pulumi.set(__self__, "hostname_label", hostname_label)
+            _setter("hostname_label", hostname_label)
         if id is not None:
-            pulumi.set(__self__, "id", id)
+            _setter("id", id)
         if ip_address is not None:
-            pulumi.set(__self__, "ip_address", ip_address)
+            _setter("ip_address", ip_address)
         if is_highly_available is not None:
-            pulumi.set(__self__, "is_highly_available", is_highly_available)
+            _setter("is_highly_available", is_highly_available)
         if maintenances is not None:
-            pulumi.set(__self__, "maintenances", maintenances)
+            _setter("maintenances", maintenances)
         if mysql_version is not None:
-            pulumi.set(__self__, "mysql_version", mysql_version)
+            _setter("mysql_version", mysql_version)
         if port is not None:
-            pulumi.set(__self__, "port", port)
+            _setter("port", port)
         if port_x is not None:
-            pulumi.set(__self__, "port_x", port_x)
+            _setter("port_x", port_x)
         if shape_name is not None:
-            pulumi.set(__self__, "shape_name", shape_name)
+            _setter("shape_name", shape_name)
         if subnet_id is not None:
-            pulumi.set(__self__, "subnet_id", subnet_id)
+            _setter("subnet_id", subnet_id)
 
     @property
     @pulumi.getter(name="adminUsername")
@@ -940,18 +1092,37 @@ class MysqlBackupDbSystemSnapshotBackupPolicyArgs:
                Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
         :param pulumi.Input[str] window_start_time: The start time of the maintenance window.
         """
+        MysqlBackupDbSystemSnapshotBackupPolicyArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            defined_tags=defined_tags,
+            freeform_tags=freeform_tags,
+            is_enabled=is_enabled,
+            pitr_policies=pitr_policies,
+            retention_in_days=retention_in_days,
+            window_start_time=window_start_time,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             defined_tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+             freeform_tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+             is_enabled: Optional[pulumi.Input[bool]] = None,
+             pitr_policies: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotBackupPolicyPitrPolicyArgs']]]] = None,
+             retention_in_days: Optional[pulumi.Input[int]] = None,
+             window_start_time: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if defined_tags is not None:
-            pulumi.set(__self__, "defined_tags", defined_tags)
+            _setter("defined_tags", defined_tags)
         if freeform_tags is not None:
-            pulumi.set(__self__, "freeform_tags", freeform_tags)
+            _setter("freeform_tags", freeform_tags)
         if is_enabled is not None:
-            pulumi.set(__self__, "is_enabled", is_enabled)
+            _setter("is_enabled", is_enabled)
         if pitr_policies is not None:
-            pulumi.set(__self__, "pitr_policies", pitr_policies)
+            _setter("pitr_policies", pitr_policies)
         if retention_in_days is not None:
-            pulumi.set(__self__, "retention_in_days", retention_in_days)
+            _setter("retention_in_days", retention_in_days)
         if window_start_time is not None:
-            pulumi.set(__self__, "window_start_time", window_start_time)
+            _setter("window_start_time", window_start_time)
 
     @property
     @pulumi.getter(name="definedTags")
@@ -1037,8 +1208,17 @@ class MysqlBackupDbSystemSnapshotBackupPolicyPitrPolicyArgs:
         """
         :param pulumi.Input[bool] is_enabled: Specifies if PITR is enabled or disabled.
         """
+        MysqlBackupDbSystemSnapshotBackupPolicyPitrPolicyArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            is_enabled=is_enabled,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             is_enabled: Optional[pulumi.Input[bool]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if is_enabled is not None:
-            pulumi.set(__self__, "is_enabled", is_enabled)
+            _setter("is_enabled", is_enabled)
 
     @property
     @pulumi.getter(name="isEnabled")
@@ -1064,12 +1244,25 @@ class MysqlBackupDbSystemSnapshotDeletionPolicyArgs:
         :param pulumi.Input[str] final_backup: Specifies whether or not a backup is taken when the DB System is deleted. REQUIRE_FINAL_BACKUP: a backup is taken if the DB System is deleted. SKIP_FINAL_BACKUP: a backup is not taken if the DB System is deleted.
         :param pulumi.Input[bool] is_delete_protected: Specifies whether the DB System can be deleted. Set to true to prevent deletion, false (default) to allow.
         """
+        MysqlBackupDbSystemSnapshotDeletionPolicyArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            automatic_backup_retention=automatic_backup_retention,
+            final_backup=final_backup,
+            is_delete_protected=is_delete_protected,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             automatic_backup_retention: Optional[pulumi.Input[str]] = None,
+             final_backup: Optional[pulumi.Input[str]] = None,
+             is_delete_protected: Optional[pulumi.Input[bool]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if automatic_backup_retention is not None:
-            pulumi.set(__self__, "automatic_backup_retention", automatic_backup_retention)
+            _setter("automatic_backup_retention", automatic_backup_retention)
         if final_backup is not None:
-            pulumi.set(__self__, "final_backup", final_backup)
+            _setter("final_backup", final_backup)
         if is_delete_protected is not None:
-            pulumi.set(__self__, "is_delete_protected", is_delete_protected)
+            _setter("is_delete_protected", is_delete_protected)
 
     @property
     @pulumi.getter(name="automaticBackupRetention")
@@ -1131,24 +1324,49 @@ class MysqlBackupDbSystemSnapshotEndpointArgs:
         :param pulumi.Input[str] status: The state of the endpoints, as far as it can seen from the DB System. There may be some inconsistency with the actual state of the MySQL service.
         :param pulumi.Input[str] status_details: Additional information about the current endpoint status.
         """
+        MysqlBackupDbSystemSnapshotEndpointArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            hostname=hostname,
+            ip_address=ip_address,
+            modes=modes,
+            port=port,
+            port_x=port_x,
+            resource_id=resource_id,
+            resource_type=resource_type,
+            status=status,
+            status_details=status_details,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             hostname: Optional[pulumi.Input[str]] = None,
+             ip_address: Optional[pulumi.Input[str]] = None,
+             modes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+             port: Optional[pulumi.Input[int]] = None,
+             port_x: Optional[pulumi.Input[int]] = None,
+             resource_id: Optional[pulumi.Input[str]] = None,
+             resource_type: Optional[pulumi.Input[str]] = None,
+             status: Optional[pulumi.Input[str]] = None,
+             status_details: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if hostname is not None:
-            pulumi.set(__self__, "hostname", hostname)
+            _setter("hostname", hostname)
         if ip_address is not None:
-            pulumi.set(__self__, "ip_address", ip_address)
+            _setter("ip_address", ip_address)
         if modes is not None:
-            pulumi.set(__self__, "modes", modes)
+            _setter("modes", modes)
         if port is not None:
-            pulumi.set(__self__, "port", port)
+            _setter("port", port)
         if port_x is not None:
-            pulumi.set(__self__, "port_x", port_x)
+            _setter("port_x", port_x)
         if resource_id is not None:
-            pulumi.set(__self__, "resource_id", resource_id)
+            _setter("resource_id", resource_id)
         if resource_type is not None:
-            pulumi.set(__self__, "resource_type", resource_type)
+            _setter("resource_type", resource_type)
         if status is not None:
-            pulumi.set(__self__, "status", status)
+            _setter("status", status)
         if status_details is not None:
-            pulumi.set(__self__, "status_details", status_details)
+            _setter("status_details", status_details)
 
     @property
     @pulumi.getter
@@ -1266,8 +1484,17 @@ class MysqlBackupDbSystemSnapshotMaintenanceArgs:
         """
         :param pulumi.Input[str] window_start_time: The start time of the maintenance window.
         """
+        MysqlBackupDbSystemSnapshotMaintenanceArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            window_start_time=window_start_time,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             window_start_time: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if window_start_time is not None:
-            pulumi.set(__self__, "window_start_time", window_start_time)
+            _setter("window_start_time", window_start_time)
 
     @property
     @pulumi.getter(name="windowStartTime")
@@ -1295,8 +1522,17 @@ class MysqlConfigurationInitVariablesArgs:
                * CASE_SENSITIVE - (default) Table and schema name comparisons are case-sensitive and stored as specified. (lower_case_table_names=0)
                * CASE_INSENSITIVE_LOWERCASE - Table and schema name comparisons are not case-sensitive and stored in lowercase. (lower_case_table_names=1)
         """
+        MysqlConfigurationInitVariablesArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            lower_case_table_names=lower_case_table_names,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             lower_case_table_names: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if lower_case_table_names is not None:
-            pulumi.set(__self__, "lower_case_table_names", lower_case_table_names)
+            _setter("lower_case_table_names", lower_case_table_names)
 
     @property
     @pulumi.getter(name="lowerCaseTableNames")
@@ -1572,185 +1808,350 @@ class MysqlConfigurationVariablesArgs:
                ** IMPORTANT **
                Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
         """
+        MysqlConfigurationVariablesArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            autocommit=autocommit,
+            big_tables=big_tables,
+            binlog_expire_logs_seconds=binlog_expire_logs_seconds,
+            binlog_row_metadata=binlog_row_metadata,
+            binlog_row_value_options=binlog_row_value_options,
+            binlog_transaction_compression=binlog_transaction_compression,
+            completion_type=completion_type,
+            connect_timeout=connect_timeout,
+            connection_memory_chunk_size=connection_memory_chunk_size,
+            connection_memory_limit=connection_memory_limit,
+            cte_max_recursion_depth=cte_max_recursion_depth,
+            default_authentication_plugin=default_authentication_plugin,
+            foreign_key_checks=foreign_key_checks,
+            generated_random_password_length=generated_random_password_length,
+            global_connection_memory_limit=global_connection_memory_limit,
+            global_connection_memory_tracking=global_connection_memory_tracking,
+            group_replication_consistency=group_replication_consistency,
+            information_schema_stats_expiry=information_schema_stats_expiry,
+            innodb_buffer_pool_dump_pct=innodb_buffer_pool_dump_pct,
+            innodb_buffer_pool_instances=innodb_buffer_pool_instances,
+            innodb_buffer_pool_size=innodb_buffer_pool_size,
+            innodb_ddl_buffer_size=innodb_ddl_buffer_size,
+            innodb_ddl_threads=innodb_ddl_threads,
+            innodb_ft_enable_stopword=innodb_ft_enable_stopword,
+            innodb_ft_max_token_size=innodb_ft_max_token_size,
+            innodb_ft_min_token_size=innodb_ft_min_token_size,
+            innodb_ft_num_word_optimize=innodb_ft_num_word_optimize,
+            innodb_ft_result_cache_limit=innodb_ft_result_cache_limit,
+            innodb_ft_server_stopword_table=innodb_ft_server_stopword_table,
+            innodb_lock_wait_timeout=innodb_lock_wait_timeout,
+            innodb_log_writer_threads=innodb_log_writer_threads,
+            innodb_max_purge_lag=innodb_max_purge_lag,
+            innodb_max_purge_lag_delay=innodb_max_purge_lag_delay,
+            innodb_stats_persistent_sample_pages=innodb_stats_persistent_sample_pages,
+            innodb_stats_transient_sample_pages=innodb_stats_transient_sample_pages,
+            interactive_timeout=interactive_timeout,
+            local_infile=local_infile,
+            mandatory_roles=mandatory_roles,
+            max_allowed_packet=max_allowed_packet,
+            max_binlog_cache_size=max_binlog_cache_size,
+            max_connect_errors=max_connect_errors,
+            max_connections=max_connections,
+            max_execution_time=max_execution_time,
+            max_heap_table_size=max_heap_table_size,
+            max_prepared_stmt_count=max_prepared_stmt_count,
+            mysql_firewall_mode=mysql_firewall_mode,
+            mysql_zstd_default_compression_level=mysql_zstd_default_compression_level,
+            mysqlx_connect_timeout=mysqlx_connect_timeout,
+            mysqlx_deflate_default_compression_level=mysqlx_deflate_default_compression_level,
+            mysqlx_deflate_max_client_compression_level=mysqlx_deflate_max_client_compression_level,
+            mysqlx_document_id_unique_prefix=mysqlx_document_id_unique_prefix,
+            mysqlx_enable_hello_notice=mysqlx_enable_hello_notice,
+            mysqlx_idle_worker_thread_timeout=mysqlx_idle_worker_thread_timeout,
+            mysqlx_interactive_timeout=mysqlx_interactive_timeout,
+            mysqlx_lz4default_compression_level=mysqlx_lz4default_compression_level,
+            mysqlx_lz4max_client_compression_level=mysqlx_lz4max_client_compression_level,
+            mysqlx_max_allowed_packet=mysqlx_max_allowed_packet,
+            mysqlx_min_worker_threads=mysqlx_min_worker_threads,
+            mysqlx_read_timeout=mysqlx_read_timeout,
+            mysqlx_wait_timeout=mysqlx_wait_timeout,
+            mysqlx_write_timeout=mysqlx_write_timeout,
+            mysqlx_zstd_default_compression_level=mysqlx_zstd_default_compression_level,
+            mysqlx_zstd_max_client_compression_level=mysqlx_zstd_max_client_compression_level,
+            net_read_timeout=net_read_timeout,
+            net_write_timeout=net_write_timeout,
+            parser_max_mem_size=parser_max_mem_size,
+            query_alloc_block_size=query_alloc_block_size,
+            query_prealloc_size=query_prealloc_size,
+            regexp_time_limit=regexp_time_limit,
+            sort_buffer_size=sort_buffer_size,
+            sql_mode=sql_mode,
+            sql_require_primary_key=sql_require_primary_key,
+            sql_warnings=sql_warnings,
+            thread_pool_dedicated_listeners=thread_pool_dedicated_listeners,
+            thread_pool_max_transactions_limit=thread_pool_max_transactions_limit,
+            time_zone=time_zone,
+            tmp_table_size=tmp_table_size,
+            transaction_isolation=transaction_isolation,
+            wait_timeout=wait_timeout,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             autocommit: Optional[pulumi.Input[bool]] = None,
+             big_tables: Optional[pulumi.Input[bool]] = None,
+             binlog_expire_logs_seconds: Optional[pulumi.Input[int]] = None,
+             binlog_row_metadata: Optional[pulumi.Input[str]] = None,
+             binlog_row_value_options: Optional[pulumi.Input[str]] = None,
+             binlog_transaction_compression: Optional[pulumi.Input[bool]] = None,
+             completion_type: Optional[pulumi.Input[str]] = None,
+             connect_timeout: Optional[pulumi.Input[int]] = None,
+             connection_memory_chunk_size: Optional[pulumi.Input[int]] = None,
+             connection_memory_limit: Optional[pulumi.Input[str]] = None,
+             cte_max_recursion_depth: Optional[pulumi.Input[str]] = None,
+             default_authentication_plugin: Optional[pulumi.Input[str]] = None,
+             foreign_key_checks: Optional[pulumi.Input[bool]] = None,
+             generated_random_password_length: Optional[pulumi.Input[int]] = None,
+             global_connection_memory_limit: Optional[pulumi.Input[str]] = None,
+             global_connection_memory_tracking: Optional[pulumi.Input[bool]] = None,
+             group_replication_consistency: Optional[pulumi.Input[str]] = None,
+             information_schema_stats_expiry: Optional[pulumi.Input[int]] = None,
+             innodb_buffer_pool_dump_pct: Optional[pulumi.Input[int]] = None,
+             innodb_buffer_pool_instances: Optional[pulumi.Input[int]] = None,
+             innodb_buffer_pool_size: Optional[pulumi.Input[str]] = None,
+             innodb_ddl_buffer_size: Optional[pulumi.Input[str]] = None,
+             innodb_ddl_threads: Optional[pulumi.Input[int]] = None,
+             innodb_ft_enable_stopword: Optional[pulumi.Input[bool]] = None,
+             innodb_ft_max_token_size: Optional[pulumi.Input[int]] = None,
+             innodb_ft_min_token_size: Optional[pulumi.Input[int]] = None,
+             innodb_ft_num_word_optimize: Optional[pulumi.Input[int]] = None,
+             innodb_ft_result_cache_limit: Optional[pulumi.Input[str]] = None,
+             innodb_ft_server_stopword_table: Optional[pulumi.Input[str]] = None,
+             innodb_lock_wait_timeout: Optional[pulumi.Input[int]] = None,
+             innodb_log_writer_threads: Optional[pulumi.Input[bool]] = None,
+             innodb_max_purge_lag: Optional[pulumi.Input[str]] = None,
+             innodb_max_purge_lag_delay: Optional[pulumi.Input[int]] = None,
+             innodb_stats_persistent_sample_pages: Optional[pulumi.Input[str]] = None,
+             innodb_stats_transient_sample_pages: Optional[pulumi.Input[str]] = None,
+             interactive_timeout: Optional[pulumi.Input[int]] = None,
+             local_infile: Optional[pulumi.Input[bool]] = None,
+             mandatory_roles: Optional[pulumi.Input[str]] = None,
+             max_allowed_packet: Optional[pulumi.Input[int]] = None,
+             max_binlog_cache_size: Optional[pulumi.Input[str]] = None,
+             max_connect_errors: Optional[pulumi.Input[str]] = None,
+             max_connections: Optional[pulumi.Input[int]] = None,
+             max_execution_time: Optional[pulumi.Input[str]] = None,
+             max_heap_table_size: Optional[pulumi.Input[str]] = None,
+             max_prepared_stmt_count: Optional[pulumi.Input[int]] = None,
+             mysql_firewall_mode: Optional[pulumi.Input[bool]] = None,
+             mysql_zstd_default_compression_level: Optional[pulumi.Input[int]] = None,
+             mysqlx_connect_timeout: Optional[pulumi.Input[int]] = None,
+             mysqlx_deflate_default_compression_level: Optional[pulumi.Input[int]] = None,
+             mysqlx_deflate_max_client_compression_level: Optional[pulumi.Input[int]] = None,
+             mysqlx_document_id_unique_prefix: Optional[pulumi.Input[int]] = None,
+             mysqlx_enable_hello_notice: Optional[pulumi.Input[bool]] = None,
+             mysqlx_idle_worker_thread_timeout: Optional[pulumi.Input[int]] = None,
+             mysqlx_interactive_timeout: Optional[pulumi.Input[int]] = None,
+             mysqlx_lz4default_compression_level: Optional[pulumi.Input[int]] = None,
+             mysqlx_lz4max_client_compression_level: Optional[pulumi.Input[int]] = None,
+             mysqlx_max_allowed_packet: Optional[pulumi.Input[int]] = None,
+             mysqlx_min_worker_threads: Optional[pulumi.Input[int]] = None,
+             mysqlx_read_timeout: Optional[pulumi.Input[int]] = None,
+             mysqlx_wait_timeout: Optional[pulumi.Input[int]] = None,
+             mysqlx_write_timeout: Optional[pulumi.Input[int]] = None,
+             mysqlx_zstd_default_compression_level: Optional[pulumi.Input[int]] = None,
+             mysqlx_zstd_max_client_compression_level: Optional[pulumi.Input[int]] = None,
+             net_read_timeout: Optional[pulumi.Input[int]] = None,
+             net_write_timeout: Optional[pulumi.Input[int]] = None,
+             parser_max_mem_size: Optional[pulumi.Input[str]] = None,
+             query_alloc_block_size: Optional[pulumi.Input[str]] = None,
+             query_prealloc_size: Optional[pulumi.Input[str]] = None,
+             regexp_time_limit: Optional[pulumi.Input[int]] = None,
+             sort_buffer_size: Optional[pulumi.Input[str]] = None,
+             sql_mode: Optional[pulumi.Input[str]] = None,
+             sql_require_primary_key: Optional[pulumi.Input[bool]] = None,
+             sql_warnings: Optional[pulumi.Input[bool]] = None,
+             thread_pool_dedicated_listeners: Optional[pulumi.Input[bool]] = None,
+             thread_pool_max_transactions_limit: Optional[pulumi.Input[int]] = None,
+             time_zone: Optional[pulumi.Input[str]] = None,
+             tmp_table_size: Optional[pulumi.Input[str]] = None,
+             transaction_isolation: Optional[pulumi.Input[str]] = None,
+             wait_timeout: Optional[pulumi.Input[int]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if autocommit is not None:
-            pulumi.set(__self__, "autocommit", autocommit)
+            _setter("autocommit", autocommit)
         if big_tables is not None:
-            pulumi.set(__self__, "big_tables", big_tables)
+            _setter("big_tables", big_tables)
         if binlog_expire_logs_seconds is not None:
-            pulumi.set(__self__, "binlog_expire_logs_seconds", binlog_expire_logs_seconds)
+            _setter("binlog_expire_logs_seconds", binlog_expire_logs_seconds)
         if binlog_row_metadata is not None:
-            pulumi.set(__self__, "binlog_row_metadata", binlog_row_metadata)
+            _setter("binlog_row_metadata", binlog_row_metadata)
         if binlog_row_value_options is not None:
-            pulumi.set(__self__, "binlog_row_value_options", binlog_row_value_options)
+            _setter("binlog_row_value_options", binlog_row_value_options)
         if binlog_transaction_compression is not None:
-            pulumi.set(__self__, "binlog_transaction_compression", binlog_transaction_compression)
+            _setter("binlog_transaction_compression", binlog_transaction_compression)
         if completion_type is not None:
-            pulumi.set(__self__, "completion_type", completion_type)
+            _setter("completion_type", completion_type)
         if connect_timeout is not None:
-            pulumi.set(__self__, "connect_timeout", connect_timeout)
+            _setter("connect_timeout", connect_timeout)
         if connection_memory_chunk_size is not None:
-            pulumi.set(__self__, "connection_memory_chunk_size", connection_memory_chunk_size)
+            _setter("connection_memory_chunk_size", connection_memory_chunk_size)
         if connection_memory_limit is not None:
-            pulumi.set(__self__, "connection_memory_limit", connection_memory_limit)
+            _setter("connection_memory_limit", connection_memory_limit)
         if cte_max_recursion_depth is not None:
-            pulumi.set(__self__, "cte_max_recursion_depth", cte_max_recursion_depth)
+            _setter("cte_max_recursion_depth", cte_max_recursion_depth)
         if default_authentication_plugin is not None:
-            pulumi.set(__self__, "default_authentication_plugin", default_authentication_plugin)
+            _setter("default_authentication_plugin", default_authentication_plugin)
         if foreign_key_checks is not None:
-            pulumi.set(__self__, "foreign_key_checks", foreign_key_checks)
+            _setter("foreign_key_checks", foreign_key_checks)
         if generated_random_password_length is not None:
             warnings.warn("""The 'generated_random_password_length' field has been deprecated and may be removed in a future version. Do not use this field.""", DeprecationWarning)
             pulumi.log.warn("""generated_random_password_length is deprecated: The 'generated_random_password_length' field has been deprecated and may be removed in a future version. Do not use this field.""")
         if generated_random_password_length is not None:
-            pulumi.set(__self__, "generated_random_password_length", generated_random_password_length)
+            _setter("generated_random_password_length", generated_random_password_length)
         if global_connection_memory_limit is not None:
-            pulumi.set(__self__, "global_connection_memory_limit", global_connection_memory_limit)
+            _setter("global_connection_memory_limit", global_connection_memory_limit)
         if global_connection_memory_tracking is not None:
-            pulumi.set(__self__, "global_connection_memory_tracking", global_connection_memory_tracking)
+            _setter("global_connection_memory_tracking", global_connection_memory_tracking)
         if group_replication_consistency is not None:
-            pulumi.set(__self__, "group_replication_consistency", group_replication_consistency)
+            _setter("group_replication_consistency", group_replication_consistency)
         if information_schema_stats_expiry is not None:
-            pulumi.set(__self__, "information_schema_stats_expiry", information_schema_stats_expiry)
+            _setter("information_schema_stats_expiry", information_schema_stats_expiry)
         if innodb_buffer_pool_dump_pct is not None:
-            pulumi.set(__self__, "innodb_buffer_pool_dump_pct", innodb_buffer_pool_dump_pct)
+            _setter("innodb_buffer_pool_dump_pct", innodb_buffer_pool_dump_pct)
         if innodb_buffer_pool_instances is not None:
-            pulumi.set(__self__, "innodb_buffer_pool_instances", innodb_buffer_pool_instances)
+            _setter("innodb_buffer_pool_instances", innodb_buffer_pool_instances)
         if innodb_buffer_pool_size is not None:
-            pulumi.set(__self__, "innodb_buffer_pool_size", innodb_buffer_pool_size)
+            _setter("innodb_buffer_pool_size", innodb_buffer_pool_size)
         if innodb_ddl_buffer_size is not None:
-            pulumi.set(__self__, "innodb_ddl_buffer_size", innodb_ddl_buffer_size)
+            _setter("innodb_ddl_buffer_size", innodb_ddl_buffer_size)
         if innodb_ddl_threads is not None:
-            pulumi.set(__self__, "innodb_ddl_threads", innodb_ddl_threads)
+            _setter("innodb_ddl_threads", innodb_ddl_threads)
         if innodb_ft_enable_stopword is not None:
-            pulumi.set(__self__, "innodb_ft_enable_stopword", innodb_ft_enable_stopword)
+            _setter("innodb_ft_enable_stopword", innodb_ft_enable_stopword)
         if innodb_ft_max_token_size is not None:
-            pulumi.set(__self__, "innodb_ft_max_token_size", innodb_ft_max_token_size)
+            _setter("innodb_ft_max_token_size", innodb_ft_max_token_size)
         if innodb_ft_min_token_size is not None:
-            pulumi.set(__self__, "innodb_ft_min_token_size", innodb_ft_min_token_size)
+            _setter("innodb_ft_min_token_size", innodb_ft_min_token_size)
         if innodb_ft_num_word_optimize is not None:
-            pulumi.set(__self__, "innodb_ft_num_word_optimize", innodb_ft_num_word_optimize)
+            _setter("innodb_ft_num_word_optimize", innodb_ft_num_word_optimize)
         if innodb_ft_result_cache_limit is not None:
-            pulumi.set(__self__, "innodb_ft_result_cache_limit", innodb_ft_result_cache_limit)
+            _setter("innodb_ft_result_cache_limit", innodb_ft_result_cache_limit)
         if innodb_ft_server_stopword_table is not None:
-            pulumi.set(__self__, "innodb_ft_server_stopword_table", innodb_ft_server_stopword_table)
+            _setter("innodb_ft_server_stopword_table", innodb_ft_server_stopword_table)
         if innodb_lock_wait_timeout is not None:
-            pulumi.set(__self__, "innodb_lock_wait_timeout", innodb_lock_wait_timeout)
+            _setter("innodb_lock_wait_timeout", innodb_lock_wait_timeout)
         if innodb_log_writer_threads is not None:
-            pulumi.set(__self__, "innodb_log_writer_threads", innodb_log_writer_threads)
+            _setter("innodb_log_writer_threads", innodb_log_writer_threads)
         if innodb_max_purge_lag is not None:
-            pulumi.set(__self__, "innodb_max_purge_lag", innodb_max_purge_lag)
+            _setter("innodb_max_purge_lag", innodb_max_purge_lag)
         if innodb_max_purge_lag_delay is not None:
-            pulumi.set(__self__, "innodb_max_purge_lag_delay", innodb_max_purge_lag_delay)
+            _setter("innodb_max_purge_lag_delay", innodb_max_purge_lag_delay)
         if innodb_stats_persistent_sample_pages is not None:
-            pulumi.set(__self__, "innodb_stats_persistent_sample_pages", innodb_stats_persistent_sample_pages)
+            _setter("innodb_stats_persistent_sample_pages", innodb_stats_persistent_sample_pages)
         if innodb_stats_transient_sample_pages is not None:
-            pulumi.set(__self__, "innodb_stats_transient_sample_pages", innodb_stats_transient_sample_pages)
+            _setter("innodb_stats_transient_sample_pages", innodb_stats_transient_sample_pages)
         if interactive_timeout is not None:
-            pulumi.set(__self__, "interactive_timeout", interactive_timeout)
+            _setter("interactive_timeout", interactive_timeout)
         if local_infile is not None:
-            pulumi.set(__self__, "local_infile", local_infile)
+            _setter("local_infile", local_infile)
         if mandatory_roles is not None:
-            pulumi.set(__self__, "mandatory_roles", mandatory_roles)
+            _setter("mandatory_roles", mandatory_roles)
         if max_allowed_packet is not None:
-            pulumi.set(__self__, "max_allowed_packet", max_allowed_packet)
+            _setter("max_allowed_packet", max_allowed_packet)
         if max_binlog_cache_size is not None:
-            pulumi.set(__self__, "max_binlog_cache_size", max_binlog_cache_size)
+            _setter("max_binlog_cache_size", max_binlog_cache_size)
         if max_connect_errors is not None:
-            pulumi.set(__self__, "max_connect_errors", max_connect_errors)
+            _setter("max_connect_errors", max_connect_errors)
         if max_connections is not None:
-            pulumi.set(__self__, "max_connections", max_connections)
+            _setter("max_connections", max_connections)
         if max_execution_time is not None:
-            pulumi.set(__self__, "max_execution_time", max_execution_time)
+            _setter("max_execution_time", max_execution_time)
         if max_heap_table_size is not None:
-            pulumi.set(__self__, "max_heap_table_size", max_heap_table_size)
+            _setter("max_heap_table_size", max_heap_table_size)
         if max_prepared_stmt_count is not None:
-            pulumi.set(__self__, "max_prepared_stmt_count", max_prepared_stmt_count)
+            _setter("max_prepared_stmt_count", max_prepared_stmt_count)
         if mysql_firewall_mode is not None:
-            pulumi.set(__self__, "mysql_firewall_mode", mysql_firewall_mode)
+            _setter("mysql_firewall_mode", mysql_firewall_mode)
         if mysql_zstd_default_compression_level is not None:
             warnings.warn("""The 'mysql_zstd_default_compression_level' field has been deprecated and may be removed in a future version. Do not use this field.""", DeprecationWarning)
             pulumi.log.warn("""mysql_zstd_default_compression_level is deprecated: The 'mysql_zstd_default_compression_level' field has been deprecated and may be removed in a future version. Do not use this field.""")
         if mysql_zstd_default_compression_level is not None:
-            pulumi.set(__self__, "mysql_zstd_default_compression_level", mysql_zstd_default_compression_level)
+            _setter("mysql_zstd_default_compression_level", mysql_zstd_default_compression_level)
         if mysqlx_connect_timeout is not None:
-            pulumi.set(__self__, "mysqlx_connect_timeout", mysqlx_connect_timeout)
+            _setter("mysqlx_connect_timeout", mysqlx_connect_timeout)
         if mysqlx_deflate_default_compression_level is not None:
-            pulumi.set(__self__, "mysqlx_deflate_default_compression_level", mysqlx_deflate_default_compression_level)
+            _setter("mysqlx_deflate_default_compression_level", mysqlx_deflate_default_compression_level)
         if mysqlx_deflate_max_client_compression_level is not None:
-            pulumi.set(__self__, "mysqlx_deflate_max_client_compression_level", mysqlx_deflate_max_client_compression_level)
+            _setter("mysqlx_deflate_max_client_compression_level", mysqlx_deflate_max_client_compression_level)
         if mysqlx_document_id_unique_prefix is not None:
             warnings.warn("""The 'mysqlx_document_id_unique_prefix' field has been deprecated and may be removed in a future version. Do not use this field.""", DeprecationWarning)
             pulumi.log.warn("""mysqlx_document_id_unique_prefix is deprecated: The 'mysqlx_document_id_unique_prefix' field has been deprecated and may be removed in a future version. Do not use this field.""")
         if mysqlx_document_id_unique_prefix is not None:
-            pulumi.set(__self__, "mysqlx_document_id_unique_prefix", mysqlx_document_id_unique_prefix)
+            _setter("mysqlx_document_id_unique_prefix", mysqlx_document_id_unique_prefix)
         if mysqlx_enable_hello_notice is not None:
-            pulumi.set(__self__, "mysqlx_enable_hello_notice", mysqlx_enable_hello_notice)
+            _setter("mysqlx_enable_hello_notice", mysqlx_enable_hello_notice)
         if mysqlx_idle_worker_thread_timeout is not None:
             warnings.warn("""The 'mysqlx_idle_worker_thread_timeout' field has been deprecated and may be removed in a future version. Do not use this field.""", DeprecationWarning)
             pulumi.log.warn("""mysqlx_idle_worker_thread_timeout is deprecated: The 'mysqlx_idle_worker_thread_timeout' field has been deprecated and may be removed in a future version. Do not use this field.""")
         if mysqlx_idle_worker_thread_timeout is not None:
-            pulumi.set(__self__, "mysqlx_idle_worker_thread_timeout", mysqlx_idle_worker_thread_timeout)
+            _setter("mysqlx_idle_worker_thread_timeout", mysqlx_idle_worker_thread_timeout)
         if mysqlx_interactive_timeout is not None:
-            pulumi.set(__self__, "mysqlx_interactive_timeout", mysqlx_interactive_timeout)
+            _setter("mysqlx_interactive_timeout", mysqlx_interactive_timeout)
         if mysqlx_lz4default_compression_level is not None:
-            pulumi.set(__self__, "mysqlx_lz4default_compression_level", mysqlx_lz4default_compression_level)
+            _setter("mysqlx_lz4default_compression_level", mysqlx_lz4default_compression_level)
         if mysqlx_lz4max_client_compression_level is not None:
-            pulumi.set(__self__, "mysqlx_lz4max_client_compression_level", mysqlx_lz4max_client_compression_level)
+            _setter("mysqlx_lz4max_client_compression_level", mysqlx_lz4max_client_compression_level)
         if mysqlx_max_allowed_packet is not None:
-            pulumi.set(__self__, "mysqlx_max_allowed_packet", mysqlx_max_allowed_packet)
+            _setter("mysqlx_max_allowed_packet", mysqlx_max_allowed_packet)
         if mysqlx_min_worker_threads is not None:
             warnings.warn("""The 'mysqlx_min_worker_threads' field has been deprecated and may be removed in a future version. Do not use this field.""", DeprecationWarning)
             pulumi.log.warn("""mysqlx_min_worker_threads is deprecated: The 'mysqlx_min_worker_threads' field has been deprecated and may be removed in a future version. Do not use this field.""")
         if mysqlx_min_worker_threads is not None:
-            pulumi.set(__self__, "mysqlx_min_worker_threads", mysqlx_min_worker_threads)
+            _setter("mysqlx_min_worker_threads", mysqlx_min_worker_threads)
         if mysqlx_read_timeout is not None:
-            pulumi.set(__self__, "mysqlx_read_timeout", mysqlx_read_timeout)
+            _setter("mysqlx_read_timeout", mysqlx_read_timeout)
         if mysqlx_wait_timeout is not None:
-            pulumi.set(__self__, "mysqlx_wait_timeout", mysqlx_wait_timeout)
+            _setter("mysqlx_wait_timeout", mysqlx_wait_timeout)
         if mysqlx_write_timeout is not None:
-            pulumi.set(__self__, "mysqlx_write_timeout", mysqlx_write_timeout)
+            _setter("mysqlx_write_timeout", mysqlx_write_timeout)
         if mysqlx_zstd_default_compression_level is not None:
-            pulumi.set(__self__, "mysqlx_zstd_default_compression_level", mysqlx_zstd_default_compression_level)
+            _setter("mysqlx_zstd_default_compression_level", mysqlx_zstd_default_compression_level)
         if mysqlx_zstd_max_client_compression_level is not None:
-            pulumi.set(__self__, "mysqlx_zstd_max_client_compression_level", mysqlx_zstd_max_client_compression_level)
+            _setter("mysqlx_zstd_max_client_compression_level", mysqlx_zstd_max_client_compression_level)
         if net_read_timeout is not None:
-            pulumi.set(__self__, "net_read_timeout", net_read_timeout)
+            _setter("net_read_timeout", net_read_timeout)
         if net_write_timeout is not None:
-            pulumi.set(__self__, "net_write_timeout", net_write_timeout)
+            _setter("net_write_timeout", net_write_timeout)
         if parser_max_mem_size is not None:
-            pulumi.set(__self__, "parser_max_mem_size", parser_max_mem_size)
+            _setter("parser_max_mem_size", parser_max_mem_size)
         if query_alloc_block_size is not None:
             warnings.warn("""The 'query_alloc_block_size' field has been deprecated and may be removed in a future version. Do not use this field.""", DeprecationWarning)
             pulumi.log.warn("""query_alloc_block_size is deprecated: The 'query_alloc_block_size' field has been deprecated and may be removed in a future version. Do not use this field.""")
         if query_alloc_block_size is not None:
-            pulumi.set(__self__, "query_alloc_block_size", query_alloc_block_size)
+            _setter("query_alloc_block_size", query_alloc_block_size)
         if query_prealloc_size is not None:
             warnings.warn("""The 'query_prealloc_size' field has been deprecated and may be removed in a future version. Do not use this field.""", DeprecationWarning)
             pulumi.log.warn("""query_prealloc_size is deprecated: The 'query_prealloc_size' field has been deprecated and may be removed in a future version. Do not use this field.""")
         if query_prealloc_size is not None:
-            pulumi.set(__self__, "query_prealloc_size", query_prealloc_size)
+            _setter("query_prealloc_size", query_prealloc_size)
         if regexp_time_limit is not None:
-            pulumi.set(__self__, "regexp_time_limit", regexp_time_limit)
+            _setter("regexp_time_limit", regexp_time_limit)
         if sort_buffer_size is not None:
-            pulumi.set(__self__, "sort_buffer_size", sort_buffer_size)
+            _setter("sort_buffer_size", sort_buffer_size)
         if sql_mode is not None:
-            pulumi.set(__self__, "sql_mode", sql_mode)
+            _setter("sql_mode", sql_mode)
         if sql_require_primary_key is not None:
-            pulumi.set(__self__, "sql_require_primary_key", sql_require_primary_key)
+            _setter("sql_require_primary_key", sql_require_primary_key)
         if sql_warnings is not None:
-            pulumi.set(__self__, "sql_warnings", sql_warnings)
+            _setter("sql_warnings", sql_warnings)
         if thread_pool_dedicated_listeners is not None:
-            pulumi.set(__self__, "thread_pool_dedicated_listeners", thread_pool_dedicated_listeners)
+            _setter("thread_pool_dedicated_listeners", thread_pool_dedicated_listeners)
         if thread_pool_max_transactions_limit is not None:
-            pulumi.set(__self__, "thread_pool_max_transactions_limit", thread_pool_max_transactions_limit)
+            _setter("thread_pool_max_transactions_limit", thread_pool_max_transactions_limit)
         if time_zone is not None:
-            pulumi.set(__self__, "time_zone", time_zone)
+            _setter("time_zone", time_zone)
         if tmp_table_size is not None:
-            pulumi.set(__self__, "tmp_table_size", tmp_table_size)
+            _setter("tmp_table_size", tmp_table_size)
         if transaction_isolation is not None:
-            pulumi.set(__self__, "transaction_isolation", transaction_isolation)
+            _setter("transaction_isolation", transaction_isolation)
         if wait_timeout is not None:
-            pulumi.set(__self__, "wait_timeout", wait_timeout)
+            _setter("wait_timeout", wait_timeout)
 
     @property
     @pulumi.getter
@@ -2839,18 +3240,37 @@ class MysqlDbSystemBackupPolicyArgs:
                
                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.
         """
+        MysqlDbSystemBackupPolicyArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            defined_tags=defined_tags,
+            freeform_tags=freeform_tags,
+            is_enabled=is_enabled,
+            pitr_policy=pitr_policy,
+            retention_in_days=retention_in_days,
+            window_start_time=window_start_time,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             defined_tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+             freeform_tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+             is_enabled: Optional[pulumi.Input[bool]] = None,
+             pitr_policy: Optional[pulumi.Input['MysqlDbSystemBackupPolicyPitrPolicyArgs']] = None,
+             retention_in_days: Optional[pulumi.Input[int]] = None,
+             window_start_time: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if defined_tags is not None:
-            pulumi.set(__self__, "defined_tags", defined_tags)
+            _setter("defined_tags", defined_tags)
         if freeform_tags is not None:
-            pulumi.set(__self__, "freeform_tags", freeform_tags)
+            _setter("freeform_tags", freeform_tags)
         if is_enabled is not None:
-            pulumi.set(__self__, "is_enabled", is_enabled)
+            _setter("is_enabled", is_enabled)
         if pitr_policy is not None:
-            pulumi.set(__self__, "pitr_policy", pitr_policy)
+            _setter("pitr_policy", pitr_policy)
         if retention_in_days is not None:
-            pulumi.set(__self__, "retention_in_days", retention_in_days)
+            _setter("retention_in_days", retention_in_days)
         if window_start_time is not None:
-            pulumi.set(__self__, "window_start_time", window_start_time)
+            _setter("window_start_time", window_start_time)
 
     @property
     @pulumi.getter(name="definedTags")
@@ -2940,8 +3360,17 @@ class MysqlDbSystemBackupPolicyPitrPolicyArgs:
         """
         :param pulumi.Input[bool] is_enabled: (Updatable) Specifies if PITR is enabled or disabled.
         """
+        MysqlDbSystemBackupPolicyPitrPolicyArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            is_enabled=is_enabled,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             is_enabled: Optional[pulumi.Input[bool]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if is_enabled is not None:
-            pulumi.set(__self__, "is_enabled", is_enabled)
+            _setter("is_enabled", is_enabled)
 
     @property
     @pulumi.getter(name="isEnabled")
@@ -2985,30 +3414,61 @@ class MysqlDbSystemChannelArgs:
         :param pulumi.Input[str] time_created: The date and time the DB System was created.
         :param pulumi.Input[str] time_updated: The time the DB System was last updated.
         """
+        MysqlDbSystemChannelArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            compartment_id=compartment_id,
+            defined_tags=defined_tags,
+            display_name=display_name,
+            freeform_tags=freeform_tags,
+            id=id,
+            is_enabled=is_enabled,
+            lifecycle_details=lifecycle_details,
+            sources=sources,
+            state=state,
+            targets=targets,
+            time_created=time_created,
+            time_updated=time_updated,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             compartment_id: Optional[pulumi.Input[str]] = None,
+             defined_tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+             display_name: Optional[pulumi.Input[str]] = None,
+             freeform_tags: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+             id: Optional[pulumi.Input[str]] = None,
+             is_enabled: Optional[pulumi.Input[bool]] = None,
+             lifecycle_details: Optional[pulumi.Input[str]] = None,
+             sources: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlDbSystemChannelSourceArgs']]]] = None,
+             state: Optional[pulumi.Input[str]] = None,
+             targets: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlDbSystemChannelTargetArgs']]]] = None,
+             time_created: Optional[pulumi.Input[str]] = None,
+             time_updated: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if compartment_id is not None:
-            pulumi.set(__self__, "compartment_id", compartment_id)
+            _setter("compartment_id", compartment_id)
         if defined_tags is not None:
-            pulumi.set(__self__, "defined_tags", defined_tags)
+            _setter("defined_tags", defined_tags)
         if display_name is not None:
-            pulumi.set(__self__, "display_name", display_name)
+            _setter("display_name", display_name)
         if freeform_tags is not None:
-            pulumi.set(__self__, "freeform_tags", freeform_tags)
+            _setter("freeform_tags", freeform_tags)
         if id is not None:
-            pulumi.set(__self__, "id", id)
+            _setter("id", id)
         if is_enabled is not None:
-            pulumi.set(__self__, "is_enabled", is_enabled)
+            _setter("is_enabled", is_enabled)
         if lifecycle_details is not None:
-            pulumi.set(__self__, "lifecycle_details", lifecycle_details)
+            _setter("lifecycle_details", lifecycle_details)
         if sources is not None:
-            pulumi.set(__self__, "sources", sources)
+            _setter("sources", sources)
         if state is not None:
-            pulumi.set(__self__, "state", state)
+            _setter("state", state)
         if targets is not None:
-            pulumi.set(__self__, "targets", targets)
+            _setter("targets", targets)
         if time_created is not None:
-            pulumi.set(__self__, "time_created", time_created)
+            _setter("time_created", time_created)
         if time_updated is not None:
-            pulumi.set(__self__, "time_updated", time_updated)
+            _setter("time_updated", time_updated)
 
     @property
     @pulumi.getter(name="compartmentId")
@@ -3174,20 +3634,41 @@ class MysqlDbSystemChannelSourceArgs:
         :param pulumi.Input[str] ssl_mode: The SSL mode of the Channel.
         :param pulumi.Input[str] username: The name of the replication user on the source MySQL instance. The username has a maximum length of 96 characters. For more information, please see the [MySQL documentation](https://dev.mysql.com/doc/refman/8.0/en/change-master-to.html)
         """
+        MysqlDbSystemChannelSourceArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            anonymous_transactions_handlings=anonymous_transactions_handlings,
+            hostname=hostname,
+            port=port,
+            source_type=source_type,
+            ssl_ca_certificates=ssl_ca_certificates,
+            ssl_mode=ssl_mode,
+            username=username,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             anonymous_transactions_handlings: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlDbSystemChannelSourceAnonymousTransactionsHandlingArgs']]]] = None,
+             hostname: Optional[pulumi.Input[str]] = None,
+             port: Optional[pulumi.Input[int]] = None,
+             source_type: Optional[pulumi.Input[str]] = None,
+             ssl_ca_certificates: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlDbSystemChannelSourceSslCaCertificateArgs']]]] = None,
+             ssl_mode: Optional[pulumi.Input[str]] = None,
+             username: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if anonymous_transactions_handlings is not None:
-            pulumi.set(__self__, "anonymous_transactions_handlings", anonymous_transactions_handlings)
+            _setter("anonymous_transactions_handlings", anonymous_transactions_handlings)
         if hostname is not None:
-            pulumi.set(__self__, "hostname", hostname)
+            _setter("hostname", hostname)
         if port is not None:
-            pulumi.set(__self__, "port", port)
+            _setter("port", port)
         if source_type is not None:
-            pulumi.set(__self__, "source_type", source_type)
+            _setter("source_type", source_type)
         if ssl_ca_certificates is not None:
-            pulumi.set(__self__, "ssl_ca_certificates", ssl_ca_certificates)
+            _setter("ssl_ca_certificates", ssl_ca_certificates)
         if ssl_mode is not None:
-            pulumi.set(__self__, "ssl_mode", ssl_mode)
+            _setter("ssl_mode", ssl_mode)
         if username is not None:
-            pulumi.set(__self__, "username", username)
+            _setter("username", username)
 
     @property
     @pulumi.getter(name="anonymousTransactionsHandlings")
@@ -3287,14 +3768,29 @@ class MysqlDbSystemChannelSourceAnonymousTransactionsHandlingArgs:
         :param pulumi.Input[str] policy: Specifies how the replication channel handles anonymous transactions.
         :param pulumi.Input[str] uuid: The UUID that is used as a prefix when generating transaction identifiers for anonymous transactions coming from the source. You can change the UUID later.
         """
+        MysqlDbSystemChannelSourceAnonymousTransactionsHandlingArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            last_configured_log_filename=last_configured_log_filename,
+            last_configured_log_offset=last_configured_log_offset,
+            policy=policy,
+            uuid=uuid,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             last_configured_log_filename: Optional[pulumi.Input[str]] = None,
+             last_configured_log_offset: Optional[pulumi.Input[str]] = None,
+             policy: Optional[pulumi.Input[str]] = None,
+             uuid: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if last_configured_log_filename is not None:
-            pulumi.set(__self__, "last_configured_log_filename", last_configured_log_filename)
+            _setter("last_configured_log_filename", last_configured_log_filename)
         if last_configured_log_offset is not None:
-            pulumi.set(__self__, "last_configured_log_offset", last_configured_log_offset)
+            _setter("last_configured_log_offset", last_configured_log_offset)
         if policy is not None:
-            pulumi.set(__self__, "policy", policy)
+            _setter("policy", policy)
         if uuid is not None:
-            pulumi.set(__self__, "uuid", uuid)
+            _setter("uuid", uuid)
 
     @property
     @pulumi.getter(name="lastConfiguredLogFilename")
@@ -3354,10 +3850,21 @@ class MysqlDbSystemChannelSourceSslCaCertificateArgs:
         :param pulumi.Input[str] certificate_type: The type of CA certificate.
         :param pulumi.Input[str] contents: The string containing the CA certificate in PEM format.
         """
+        MysqlDbSystemChannelSourceSslCaCertificateArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            certificate_type=certificate_type,
+            contents=contents,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             certificate_type: Optional[pulumi.Input[str]] = None,
+             contents: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if certificate_type is not None:
-            pulumi.set(__self__, "certificate_type", certificate_type)
+            _setter("certificate_type", certificate_type)
         if contents is not None:
-            pulumi.set(__self__, "contents", contents)
+            _setter("contents", contents)
 
     @property
     @pulumi.getter(name="certificateType")
@@ -3403,20 +3910,41 @@ class MysqlDbSystemChannelTargetArgs:
         :param pulumi.Input[str] tables_without_primary_key_handling: Specifies how a replication channel handles the creation and alteration of tables  that do not have a primary key.
         :param pulumi.Input[str] target_type: The specific target identifier.
         """
+        MysqlDbSystemChannelTargetArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            applier_username=applier_username,
+            channel_name=channel_name,
+            db_system_id=db_system_id,
+            delay_in_seconds=delay_in_seconds,
+            filters=filters,
+            tables_without_primary_key_handling=tables_without_primary_key_handling,
+            target_type=target_type,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             applier_username: Optional[pulumi.Input[str]] = None,
+             channel_name: Optional[pulumi.Input[str]] = None,
+             db_system_id: Optional[pulumi.Input[str]] = None,
+             delay_in_seconds: Optional[pulumi.Input[int]] = None,
+             filters: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlDbSystemChannelTargetFilterArgs']]]] = None,
+             tables_without_primary_key_handling: Optional[pulumi.Input[str]] = None,
+             target_type: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if applier_username is not None:
-            pulumi.set(__self__, "applier_username", applier_username)
+            _setter("applier_username", applier_username)
         if channel_name is not None:
-            pulumi.set(__self__, "channel_name", channel_name)
+            _setter("channel_name", channel_name)
         if db_system_id is not None:
-            pulumi.set(__self__, "db_system_id", db_system_id)
+            _setter("db_system_id", db_system_id)
         if delay_in_seconds is not None:
-            pulumi.set(__self__, "delay_in_seconds", delay_in_seconds)
+            _setter("delay_in_seconds", delay_in_seconds)
         if filters is not None:
-            pulumi.set(__self__, "filters", filters)
+            _setter("filters", filters)
         if tables_without_primary_key_handling is not None:
-            pulumi.set(__self__, "tables_without_primary_key_handling", tables_without_primary_key_handling)
+            _setter("tables_without_primary_key_handling", tables_without_primary_key_handling)
         if target_type is not None:
-            pulumi.set(__self__, "target_type", target_type)
+            _setter("target_type", target_type)
 
     @property
     @pulumi.getter(name="applierUsername")
@@ -3512,10 +4040,21 @@ class MysqlDbSystemChannelTargetFilterArgs:
         :param pulumi.Input[str] type: The type of the filter rule.
         :param pulumi.Input[str] value: The body of the filter rule. This can represent a database, a table, or a database pair (represented as "db1->db2"). For more information, see [Replication Filtering Rules](https://dev.mysql.com/doc/refman/8.0/en/replication-rules.html).
         """
+        MysqlDbSystemChannelTargetFilterArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            type=type,
+            value=value,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             type: Optional[pulumi.Input[str]] = None,
+             value: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if type is not None:
-            pulumi.set(__self__, "type", type)
+            _setter("type", type)
         if value is not None:
-            pulumi.set(__self__, "value", value)
+            _setter("value", value)
 
     @property
     @pulumi.getter
@@ -3559,10 +4098,21 @@ class MysqlDbSystemCurrentPlacementArgs:
                
                For a standalone DB System, this defines the fault domain in which the DB System is placed.
         """
+        MysqlDbSystemCurrentPlacementArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            availability_domain=availability_domain,
+            fault_domain=fault_domain,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             availability_domain: Optional[pulumi.Input[str]] = None,
+             fault_domain: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if availability_domain is not None:
-            pulumi.set(__self__, "availability_domain", availability_domain)
+            _setter("availability_domain", availability_domain)
         if fault_domain is not None:
-            pulumi.set(__self__, "fault_domain", fault_domain)
+            _setter("fault_domain", fault_domain)
 
     @property
     @pulumi.getter(name="availabilityDomain")
@@ -3608,12 +4158,25 @@ class MysqlDbSystemDeletionPolicyArgs:
         :param pulumi.Input[str] final_backup: (Updatable) Specifies whether or not a backup is taken when the DB System is deleted. REQUIRE_FINAL_BACKUP: a backup is taken if the DB System is deleted. SKIP_FINAL_BACKUP: a backup is not taken if the DB System is deleted.
         :param pulumi.Input[bool] is_delete_protected: (Updatable) Specifies whether the DB System can be deleted. Set to true to prevent deletion, false (default) to allow.
         """
+        MysqlDbSystemDeletionPolicyArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            automatic_backup_retention=automatic_backup_retention,
+            final_backup=final_backup,
+            is_delete_protected=is_delete_protected,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             automatic_backup_retention: Optional[pulumi.Input[str]] = None,
+             final_backup: Optional[pulumi.Input[str]] = None,
+             is_delete_protected: Optional[pulumi.Input[bool]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if automatic_backup_retention is not None:
-            pulumi.set(__self__, "automatic_backup_retention", automatic_backup_retention)
+            _setter("automatic_backup_retention", automatic_backup_retention)
         if final_backup is not None:
-            pulumi.set(__self__, "final_backup", final_backup)
+            _setter("final_backup", final_backup)
         if is_delete_protected is not None:
-            pulumi.set(__self__, "is_delete_protected", is_delete_protected)
+            _setter("is_delete_protected", is_delete_protected)
 
     @property
     @pulumi.getter(name="automaticBackupRetention")
@@ -3675,24 +4238,49 @@ class MysqlDbSystemEndpointArgs:
         :param pulumi.Input[str] status: The state of the endpoints, as far as it can seen from the DB System. There may be some inconsistency with the actual state of the MySQL service.
         :param pulumi.Input[str] status_details: Additional information about the current endpoint status.
         """
+        MysqlDbSystemEndpointArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            hostname=hostname,
+            ip_address=ip_address,
+            modes=modes,
+            port=port,
+            port_x=port_x,
+            resource_id=resource_id,
+            resource_type=resource_type,
+            status=status,
+            status_details=status_details,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             hostname: Optional[pulumi.Input[str]] = None,
+             ip_address: Optional[pulumi.Input[str]] = None,
+             modes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+             port: Optional[pulumi.Input[int]] = None,
+             port_x: Optional[pulumi.Input[int]] = None,
+             resource_id: Optional[pulumi.Input[str]] = None,
+             resource_type: Optional[pulumi.Input[str]] = None,
+             status: Optional[pulumi.Input[str]] = None,
+             status_details: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if hostname is not None:
-            pulumi.set(__self__, "hostname", hostname)
+            _setter("hostname", hostname)
         if ip_address is not None:
-            pulumi.set(__self__, "ip_address", ip_address)
+            _setter("ip_address", ip_address)
         if modes is not None:
-            pulumi.set(__self__, "modes", modes)
+            _setter("modes", modes)
         if port is not None:
-            pulumi.set(__self__, "port", port)
+            _setter("port", port)
         if port_x is not None:
-            pulumi.set(__self__, "port_x", port_x)
+            _setter("port_x", port_x)
         if resource_id is not None:
-            pulumi.set(__self__, "resource_id", resource_id)
+            _setter("resource_id", resource_id)
         if resource_type is not None:
-            pulumi.set(__self__, "resource_type", resource_type)
+            _setter("resource_type", resource_type)
         if status is not None:
-            pulumi.set(__self__, "status", status)
+            _setter("status", status)
         if status_details is not None:
-            pulumi.set(__self__, "status_details", status_details)
+            _setter("status_details", status_details)
 
     @property
     @pulumi.getter
@@ -3821,18 +4409,37 @@ class MysqlDbSystemHeatWaveClusterArgs:
         :param pulumi.Input[str] time_created: The date and time the DB System was created.
         :param pulumi.Input[str] time_updated: The time the DB System was last updated.
         """
+        MysqlDbSystemHeatWaveClusterArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            cluster_size=cluster_size,
+            is_lakehouse_enabled=is_lakehouse_enabled,
+            shape_name=shape_name,
+            state=state,
+            time_created=time_created,
+            time_updated=time_updated,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             cluster_size: Optional[pulumi.Input[int]] = None,
+             is_lakehouse_enabled: Optional[pulumi.Input[bool]] = None,
+             shape_name: Optional[pulumi.Input[str]] = None,
+             state: Optional[pulumi.Input[str]] = None,
+             time_created: Optional[pulumi.Input[str]] = None,
+             time_updated: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if cluster_size is not None:
-            pulumi.set(__self__, "cluster_size", cluster_size)
+            _setter("cluster_size", cluster_size)
         if is_lakehouse_enabled is not None:
-            pulumi.set(__self__, "is_lakehouse_enabled", is_lakehouse_enabled)
+            _setter("is_lakehouse_enabled", is_lakehouse_enabled)
         if shape_name is not None:
-            pulumi.set(__self__, "shape_name", shape_name)
+            _setter("shape_name", shape_name)
         if state is not None:
-            pulumi.set(__self__, "state", state)
+            _setter("state", state)
         if time_created is not None:
-            pulumi.set(__self__, "time_created", time_created)
+            _setter("time_created", time_created)
         if time_updated is not None:
-            pulumi.set(__self__, "time_updated", time_updated)
+            _setter("time_updated", time_updated)
 
     @property
     @pulumi.getter(name="clusterSize")
@@ -3923,7 +4530,16 @@ class MysqlDbSystemMaintenanceArgs:
                
                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.
         """
-        pulumi.set(__self__, "window_start_time", window_start_time)
+        MysqlDbSystemMaintenanceArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            window_start_time=window_start_time,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             window_start_time: pulumi.Input[str],
+             opts: Optional[pulumi.ResourceOptions]=None):
+        _setter("window_start_time", window_start_time)
 
     @property
     @pulumi.getter(name="windowStartTime")
@@ -3955,10 +4571,21 @@ class MysqlDbSystemPointInTimeRecoveryDetailArgs:
         :param pulumi.Input[str] time_earliest_recovery_point: Earliest recovery time point for the DB System, as described by [RFC 3339](https://tools.ietf.org/rfc/rfc3339).
         :param pulumi.Input[str] time_latest_recovery_point: Latest recovery time point for the DB System, as described by [RFC 3339](https://tools.ietf.org/rfc/rfc3339).
         """
+        MysqlDbSystemPointInTimeRecoveryDetailArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            time_earliest_recovery_point=time_earliest_recovery_point,
+            time_latest_recovery_point=time_latest_recovery_point,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             time_earliest_recovery_point: Optional[pulumi.Input[str]] = None,
+             time_latest_recovery_point: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
         if time_earliest_recovery_point is not None:
-            pulumi.set(__self__, "time_earliest_recovery_point", time_earliest_recovery_point)
+            _setter("time_earliest_recovery_point", time_earliest_recovery_point)
         if time_latest_recovery_point is not None:
-            pulumi.set(__self__, "time_latest_recovery_point", time_latest_recovery_point)
+            _setter("time_latest_recovery_point", time_latest_recovery_point)
 
     @property
     @pulumi.getter(name="timeEarliestRecoveryPoint")
@@ -4000,15 +4627,32 @@ class MysqlDbSystemSourceArgs:
         :param pulumi.Input[str] recovery_point: The date and time, as per RFC 3339, of the change up to which the new DB System shall be restored to, using a backup and logs from the original DB System. In case no point in time is specified, then this new DB System shall be restored up to the latest change recorded for the original DB System.
         :param pulumi.Input[str] source_url: The Pre-Authenticated Request (PAR) of a bucket/prefix or PAR of a @.manifest.json object from the Object Storage. Check [Using Pre-Authenticated Requests](https://docs.oracle.com/en-us/iaas/Content/Object/Tasks/usingpreauthenticatedrequests.htm) for information related to PAR creation. Please create PAR with "Permit object reads" access type and "Enable Object Listing" permission when using a bucket/prefix PAR. Please create PAR with "Permit object reads" access type when using a @.manifest.json object PAR.
         """
-        pulumi.set(__self__, "source_type", source_type)
+        MysqlDbSystemSourceArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            source_type=source_type,
+            backup_id=backup_id,
+            db_system_id=db_system_id,
+            recovery_point=recovery_point,
+            source_url=source_url,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             source_type: pulumi.Input[str],
+             backup_id: Optional[pulumi.Input[str]] = None,
+             db_system_id: Optional[pulumi.Input[str]] = None,
+             recovery_point: Optional[pulumi.Input[str]] = None,
+             source_url: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
+        _setter("source_type", source_type)
         if backup_id is not None:
-            pulumi.set(__self__, "backup_id", backup_id)
+            _setter("backup_id", backup_id)
         if db_system_id is not None:
-            pulumi.set(__self__, "db_system_id", db_system_id)
+            _setter("db_system_id", db_system_id)
         if recovery_point is not None:
-            pulumi.set(__self__, "recovery_point", recovery_point)
+            _setter("recovery_point", recovery_point)
         if source_url is not None:
-            pulumi.set(__self__, "source_url", source_url)
+            _setter("source_url", source_url)
 
     @property
     @pulumi.getter(name="sourceType")
@@ -4071,16 +4715,105 @@ class MysqlDbSystemSourceArgs:
         pulumi.set(self, "source_url", value)
 
 
+@pulumi.input_type
+class ReplicaReplicaOverridesArgs:
+    def __init__(__self__, *,
+                 configuration_id: Optional[pulumi.Input[str]] = None,
+                 mysql_version: Optional[pulumi.Input[str]] = None,
+                 shape_name: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] configuration_id: (Updatable) The OCID of the Configuration to be used by the read replica.
+        :param pulumi.Input[str] mysql_version: (Updatable) The MySQL version to be used by the read replica.
+        :param pulumi.Input[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. 
+               
+               
+               ** IMPORTANT **
+               Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
+        """
+        ReplicaReplicaOverridesArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            configuration_id=configuration_id,
+            mysql_version=mysql_version,
+            shape_name=shape_name,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             configuration_id: Optional[pulumi.Input[str]] = None,
+             mysql_version: Optional[pulumi.Input[str]] = None,
+             shape_name: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
+        if configuration_id is not None:
+            _setter("configuration_id", configuration_id)
+        if mysql_version is not None:
+            _setter("mysql_version", mysql_version)
+        if shape_name is not None:
+            _setter("shape_name", shape_name)
+
+    @property
+    @pulumi.getter(name="configurationId")
+    def configuration_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Updatable) The OCID of the Configuration to be used by the read replica.
+        """
+        return pulumi.get(self, "configuration_id")
+
+    @configuration_id.setter
+    def configuration_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "configuration_id", value)
+
+    @property
+    @pulumi.getter(name="mysqlVersion")
+    def mysql_version(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Updatable) The MySQL version to be used by the read replica.
+        """
+        return pulumi.get(self, "mysql_version")
+
+    @mysql_version.setter
+    def mysql_version(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "mysql_version", value)
+
+    @property
+    @pulumi.getter(name="shapeName")
+    def shape_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        (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. 
+
+
+        ** IMPORTANT **
+        Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
+        """
+        return pulumi.get(self, "shape_name")
+
+    @shape_name.setter
+    def shape_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "shape_name", value)
+
+
 @pulumi.input_type
 class GetChannelsFilterArgs:
     def __init__(__self__, *,
                  name: str,
                  values: Sequence[str],
                  regex: Optional[bool] = None):
-        pulumi.set(__self__, "name", name)
-        pulumi.set(__self__, "values", values)
+        GetChannelsFilterArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            name=name,
+            values=values,
+            regex=regex,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             name: str,
+             values: Sequence[str],
+             regex: Optional[bool] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
+        _setter("name", name)
+        _setter("values", values)
         if regex is not None:
-            pulumi.set(__self__, "regex", regex)
+            _setter("regex", regex)
 
     @property
     @pulumi.getter
@@ -4116,10 +4849,23 @@ class GetMysqlBackupsFilterArgs:
                  name: str,
                  values: Sequence[str],
                  regex: Optional[bool] = None):
-        pulumi.set(__self__, "name", name)
-        pulumi.set(__self__, "values", values)
+        GetMysqlBackupsFilterArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            name=name,
+            values=values,
+            regex=regex,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             name: str,
+             values: Sequence[str],
+             regex: Optional[bool] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
+        _setter("name", name)
+        _setter("values", values)
         if regex is not None:
-            pulumi.set(__self__, "regex", regex)
+            _setter("regex", regex)
 
     @property
     @pulumi.getter
@@ -4155,10 +4901,23 @@ class GetMysqlConfigurationsFilterArgs:
                  name: str,
                  values: Sequence[str],
                  regex: Optional[bool] = None):
-        pulumi.set(__self__, "name", name)
-        pulumi.set(__self__, "values", values)
+        GetMysqlConfigurationsFilterArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            name=name,
+            values=values,
+            regex=regex,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             name: str,
+             values: Sequence[str],
+             regex: Optional[bool] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
+        _setter("name", name)
+        _setter("values", values)
         if regex is not None:
-            pulumi.set(__self__, "regex", regex)
+            _setter("regex", regex)
 
     @property
     @pulumi.getter
@@ -4194,10 +4953,23 @@ class GetMysqlDbSystemsFilterArgs:
                  name: str,
                  values: Sequence[str],
                  regex: Optional[bool] = None):
-        pulumi.set(__self__, "name", name)
-        pulumi.set(__self__, "values", values)
+        GetMysqlDbSystemsFilterArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            name=name,
+            values=values,
+            regex=regex,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             name: str,
+             values: Sequence[str],
+             regex: Optional[bool] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
+        _setter("name", name)
+        _setter("values", values)
         if regex is not None:
-            pulumi.set(__self__, "regex", regex)
+            _setter("regex", regex)
 
     @property
     @pulumi.getter
@@ -4233,10 +5005,23 @@ class GetMysqlVersionFilterArgs:
                  name: str,
                  values: Sequence[str],
                  regex: Optional[bool] = None):
-        pulumi.set(__self__, "name", name)
-        pulumi.set(__self__, "values", values)
+        GetMysqlVersionFilterArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            name=name,
+            values=values,
+            regex=regex,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             name: str,
+             values: Sequence[str],
+             regex: Optional[bool] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
+        _setter("name", name)
+        _setter("values", values)
         if regex is not None:
-            pulumi.set(__self__, "regex", regex)
+            _setter("regex", regex)
 
     @property
     @pulumi.getter
@@ -4272,10 +5057,23 @@ class GetReplicasFilterArgs:
                  name: str,
                  values: Sequence[str],
                  regex: Optional[bool] = None):
-        pulumi.set(__self__, "name", name)
-        pulumi.set(__self__, "values", values)
+        GetReplicasFilterArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            name=name,
+            values=values,
+            regex=regex,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             name: str,
+             values: Sequence[str],
+             regex: Optional[bool] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
+        _setter("name", name)
+        _setter("values", values)
         if regex is not None:
-            pulumi.set(__self__, "regex", regex)
+            _setter("regex", regex)
 
     @property
     @pulumi.getter
@@ -4314,10 +5112,23 @@ class GetShapesFilterArgs:
         """
         :param str name: Name
         """
-        pulumi.set(__self__, "name", name)
-        pulumi.set(__self__, "values", values)
+        GetShapesFilterArgs._configure(
+            lambda key, value: pulumi.set(__self__, key, value),
+            name=name,
+            values=values,
+            regex=regex,
+        )
+    @staticmethod
+    def _configure(
+             _setter: Callable[[Any, Any], None],
+             name: str,
+             values: Sequence[str],
+             regex: Optional[bool] = None,
+             opts: Optional[pulumi.ResourceOptions]=None):
+        _setter("name", name)
+        _setter("values", values)
         if regex is not None:
-            pulumi.set(__self__, "regex", regex)
+            _setter("regex", regex)
 
     @property
     @pulumi.getter