pulumi-oci 2.25.0a1740032973__py3-none-any.whl → 2.26.0__py3-none-any.whl

pulumi_oci/database/_inputs.py

@@ -15,10 +15,14 @@ else:
 from .. import _utilities
 
 __all__ = [
+    'AutonomousContainerDatabaseAssociatedBackupConfigurationDetailArgs',
+    'AutonomousContainerDatabaseAssociatedBackupConfigurationDetailArgsDict',
     'AutonomousContainerDatabaseBackupConfigArgs',
     'AutonomousContainerDatabaseBackupConfigArgsDict',
     'AutonomousContainerDatabaseBackupConfigBackupDestinationDetailsArgs',
     'AutonomousContainerDatabaseBackupConfigBackupDestinationDetailsArgsDict',
+    'AutonomousContainerDatabaseBackupDestinationPropertiesListArgs',
+    'AutonomousContainerDatabaseBackupDestinationPropertiesListArgsDict',
     'AutonomousContainerDatabaseDataguardAssociationPeerAutonomousContainerDatabaseBackupConfigArgs',
     'AutonomousContainerDatabaseDataguardAssociationPeerAutonomousContainerDatabaseBackupConfigArgsDict',
     'AutonomousContainerDatabaseDataguardAssociationPeerAutonomousContainerDatabaseBackupConfigBackupDestinationDetailArgs',
@@ -41,6 +45,8 @@ __all__ = [
     'AutonomousContainerDatabasePeerAutonomousContainerDatabaseBackupConfigArgsDict',
     'AutonomousContainerDatabasePeerAutonomousContainerDatabaseBackupConfigBackupDestinationDetailArgs',
     'AutonomousContainerDatabasePeerAutonomousContainerDatabaseBackupConfigBackupDestinationDetailArgsDict',
+    'AutonomousContainerDatabaseRecoveryApplianceDetailArgs',
+    'AutonomousContainerDatabaseRecoveryApplianceDetailArgsDict',
     'AutonomousDatabaseApexDetailArgs',
     'AutonomousDatabaseApexDetailArgsDict',
     'AutonomousDatabaseBackupBackupDestinationDetailsArgs',
@@ -247,10 +253,26 @@ __all__ = [
     'ExadataInfrastructureComputeMaintenanceWindowDaysOfWeekArgsDict',
     'ExadataInfrastructureComputeMaintenanceWindowMonthArgs',
     'ExadataInfrastructureComputeMaintenanceWindowMonthArgsDict',
+    'ExadataInfrastructureConfigureExascaleManagementContactArgs',
+    'ExadataInfrastructureConfigureExascaleManagementContactArgsDict',
+    'ExadataInfrastructureConfigureExascaleManagementDefinedFileSystemConfigurationArgs',
+    'ExadataInfrastructureConfigureExascaleManagementDefinedFileSystemConfigurationArgsDict',
+    'ExadataInfrastructureConfigureExascaleManagementExascaleConfigArgs',
+    'ExadataInfrastructureConfigureExascaleManagementExascaleConfigArgsDict',
+    'ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowArgs',
+    'ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowArgsDict',
+    'ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowDaysOfWeekArgs',
+    'ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowDaysOfWeekArgsDict',
+    'ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowMonthArgs',
+    'ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowMonthArgsDict',
+    'ExadataInfrastructureConfigureExascaleManagementNetworkBondingModeDetailArgs',
+    'ExadataInfrastructureConfigureExascaleManagementNetworkBondingModeDetailArgsDict',
     'ExadataInfrastructureContactArgs',
     'ExadataInfrastructureContactArgsDict',
     'ExadataInfrastructureDefinedFileSystemConfigurationArgs',
     'ExadataInfrastructureDefinedFileSystemConfigurationArgsDict',
+    'ExadataInfrastructureExascaleConfigArgs',
+    'ExadataInfrastructureExascaleConfigArgsDict',
     'ExadataInfrastructureMaintenanceWindowArgs',
     'ExadataInfrastructureMaintenanceWindowArgsDict',
     'ExadataInfrastructureMaintenanceWindowDaysOfWeekArgs',
@@ -559,6 +581,218 @@ __all__ = [
 
 MYPY = False
 
+if not MYPY:
+    class AutonomousContainerDatabaseAssociatedBackupConfigurationDetailArgsDict(TypedDict):
+        backup_destination_attach_histories: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The timestamps at which this backup destination is used as the preferred destination to host the Autonomous Container Database backups.
+        """
+        dbrs_policy_id: NotRequired[pulumi.Input[str]]
+        """
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the DBRS policy used for backup.
+        """
+        id: NotRequired[pulumi.Input[str]]
+        """
+        The id of the Autonomous Database [Vault](https://docs.cloud.oracle.com/iaas/Content/KeyManagement/Concepts/keyoverview.htm#concepts) service key management history entry.
+        """
+        internet_proxy: NotRequired[pulumi.Input[str]]
+        """
+        Proxy URL to connect to object store.
+        """
+        recovery_window_in_days: NotRequired[pulumi.Input[int]]
+        """
+        Number of days between the current and earliest point of recoverability covered by automatic backups.
+        """
+        space_utilized_in_gbs: NotRequired[pulumi.Input[int]]
+        """
+        The total space utilized (in GBs) by this Autonomous Container Database on this backup destination, rounded to the nearest integer.
+        """
+        time_at_which_storage_details_are_updated: NotRequired[pulumi.Input[str]]
+        """
+        The latest timestamp when the backup destination details, such as 'spaceUtilized,' are updated.
+        """
+        type: NotRequired[pulumi.Input[str]]
+        """
+        Type of the database backup destination.
+        """
+        vpc_password: NotRequired[pulumi.Input[str]]
+        """
+        For a RECOVERY_APPLIANCE backup destination, the password for the VPC user that is used to access the Recovery Appliance.
+        """
+        vpc_user: NotRequired[pulumi.Input[str]]
+        """
+        For a RECOVERY_APPLIANCE backup destination, the Virtual Private Catalog (VPC) user that is used to access the Recovery Appliance.
+        """
+elif False:
+    AutonomousContainerDatabaseAssociatedBackupConfigurationDetailArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class AutonomousContainerDatabaseAssociatedBackupConfigurationDetailArgs:
+    def __init__(__self__, *,
+                 backup_destination_attach_histories: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 dbrs_policy_id: Optional[pulumi.Input[str]] = None,
+                 id: Optional[pulumi.Input[str]] = None,
+                 internet_proxy: Optional[pulumi.Input[str]] = None,
+                 recovery_window_in_days: Optional[pulumi.Input[int]] = None,
+                 space_utilized_in_gbs: Optional[pulumi.Input[int]] = None,
+                 time_at_which_storage_details_are_updated: Optional[pulumi.Input[str]] = None,
+                 type: Optional[pulumi.Input[str]] = None,
+                 vpc_password: Optional[pulumi.Input[str]] = None,
+                 vpc_user: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] backup_destination_attach_histories: The timestamps at which this backup destination is used as the preferred destination to host the Autonomous Container Database backups.
+        :param pulumi.Input[str] dbrs_policy_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the DBRS policy used for backup.
+        :param pulumi.Input[str] id: The id of the Autonomous Database [Vault](https://docs.cloud.oracle.com/iaas/Content/KeyManagement/Concepts/keyoverview.htm#concepts) service key management history entry.
+        :param pulumi.Input[str] internet_proxy: Proxy URL to connect to object store.
+        :param pulumi.Input[int] recovery_window_in_days: Number of days between the current and earliest point of recoverability covered by automatic backups.
+        :param pulumi.Input[int] space_utilized_in_gbs: The total space utilized (in GBs) by this Autonomous Container Database on this backup destination, rounded to the nearest integer.
+        :param pulumi.Input[str] time_at_which_storage_details_are_updated: The latest timestamp when the backup destination details, such as 'spaceUtilized,' are updated.
+        :param pulumi.Input[str] type: Type of the database backup destination.
+        :param pulumi.Input[str] vpc_password: For a RECOVERY_APPLIANCE backup destination, the password for the VPC user that is used to access the Recovery Appliance.
+        :param pulumi.Input[str] vpc_user: For a RECOVERY_APPLIANCE backup destination, the Virtual Private Catalog (VPC) user that is used to access the Recovery Appliance.
+        """
+        if backup_destination_attach_histories is not None:
+            pulumi.set(__self__, "backup_destination_attach_histories", backup_destination_attach_histories)
+        if dbrs_policy_id is not None:
+            pulumi.set(__self__, "dbrs_policy_id", dbrs_policy_id)
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+        if internet_proxy is not None:
+            pulumi.set(__self__, "internet_proxy", internet_proxy)
+        if recovery_window_in_days is not None:
+            pulumi.set(__self__, "recovery_window_in_days", recovery_window_in_days)
+        if space_utilized_in_gbs is not None:
+            pulumi.set(__self__, "space_utilized_in_gbs", space_utilized_in_gbs)
+        if time_at_which_storage_details_are_updated is not None:
+            pulumi.set(__self__, "time_at_which_storage_details_are_updated", time_at_which_storage_details_are_updated)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+        if vpc_password is not None:
+            pulumi.set(__self__, "vpc_password", vpc_password)
+        if vpc_user is not None:
+            pulumi.set(__self__, "vpc_user", vpc_user)
+
+    @property
+    @pulumi.getter(name="backupDestinationAttachHistories")
+    def backup_destination_attach_histories(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        The timestamps at which this backup destination is used as the preferred destination to host the Autonomous Container Database backups.
+        """
+        return pulumi.get(self, "backup_destination_attach_histories")
+
+    @backup_destination_attach_histories.setter
+    def backup_destination_attach_histories(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "backup_destination_attach_histories", value)
+
+    @property
+    @pulumi.getter(name="dbrsPolicyId")
+    def dbrs_policy_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the DBRS policy used for backup.
+        """
+        return pulumi.get(self, "dbrs_policy_id")
+
+    @dbrs_policy_id.setter
+    def dbrs_policy_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "dbrs_policy_id", value)
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The id of the Autonomous Database [Vault](https://docs.cloud.oracle.com/iaas/Content/KeyManagement/Concepts/keyoverview.htm#concepts) service key management history entry.
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "id", value)
+
+    @property
+    @pulumi.getter(name="internetProxy")
+    def internet_proxy(self) -> Optional[pulumi.Input[str]]:
+        """
+        Proxy URL to connect to object store.
+        """
+        return pulumi.get(self, "internet_proxy")
+
+    @internet_proxy.setter
+    def internet_proxy(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "internet_proxy", value)
+
+    @property
+    @pulumi.getter(name="recoveryWindowInDays")
+    def recovery_window_in_days(self) -> Optional[pulumi.Input[int]]:
+        """
+        Number of days between the current and earliest point of recoverability covered by automatic backups.
+        """
+        return pulumi.get(self, "recovery_window_in_days")
+
+    @recovery_window_in_days.setter
+    def recovery_window_in_days(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "recovery_window_in_days", value)
+
+    @property
+    @pulumi.getter(name="spaceUtilizedInGbs")
+    def space_utilized_in_gbs(self) -> Optional[pulumi.Input[int]]:
+        """
+        The total space utilized (in GBs) by this Autonomous Container Database on this backup destination, rounded to the nearest integer.
+        """
+        return pulumi.get(self, "space_utilized_in_gbs")
+
+    @space_utilized_in_gbs.setter
+    def space_utilized_in_gbs(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "space_utilized_in_gbs", value)
+
+    @property
+    @pulumi.getter(name="timeAtWhichStorageDetailsAreUpdated")
+    def time_at_which_storage_details_are_updated(self) -> Optional[pulumi.Input[str]]:
+        """
+        The latest timestamp when the backup destination details, such as 'spaceUtilized,' are updated.
+        """
+        return pulumi.get(self, "time_at_which_storage_details_are_updated")
+
+    @time_at_which_storage_details_are_updated.setter
+    def time_at_which_storage_details_are_updated(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "time_at_which_storage_details_are_updated", value)
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[pulumi.Input[str]]:
+        """
+        Type of the database backup destination.
+        """
+        return pulumi.get(self, "type")
+
+    @type.setter
+    def type(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "type", value)
+
+    @property
+    @pulumi.getter(name="vpcPassword")
+    def vpc_password(self) -> Optional[pulumi.Input[str]]:
+        """
+        For a RECOVERY_APPLIANCE backup destination, the password for the VPC user that is used to access the Recovery Appliance.
+        """
+        return pulumi.get(self, "vpc_password")
+
+    @vpc_password.setter
+    def vpc_password(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "vpc_password", value)
+
+    @property
+    @pulumi.getter(name="vpcUser")
+    def vpc_user(self) -> Optional[pulumi.Input[str]]:
+        """
+        For a RECOVERY_APPLIANCE backup destination, the Virtual Private Catalog (VPC) user that is used to access the Recovery Appliance.
+        """
+        return pulumi.get(self, "vpc_user")
+
+    @vpc_user.setter
+    def vpc_user(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "vpc_user", value)
+
+
 if not MYPY:
     class AutonomousContainerDatabaseBackupConfigArgsDict(TypedDict):
         backup_destination_details: NotRequired[pulumi.Input['AutonomousContainerDatabaseBackupConfigBackupDestinationDetailsArgsDict']]
@@ -722,6 +956,78 @@ class AutonomousContainerDatabaseBackupConfigBackupDestinationDetailsArgs:
         pulumi.set(self, "vpc_user", value)
 
 
+if not MYPY:
+    class AutonomousContainerDatabaseBackupDestinationPropertiesListArgsDict(TypedDict):
+        backup_destination_attach_histories: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The timestamps at which this backup destination is used as the preferred destination to host the Autonomous Container Database backups.
+        """
+        space_utilized_in_gbs: NotRequired[pulumi.Input[int]]
+        """
+        The total space utilized (in GBs) by this Autonomous Container Database on this backup destination, rounded to the nearest integer.
+        """
+        time_at_which_storage_details_are_updated: NotRequired[pulumi.Input[str]]
+        """
+        The latest timestamp when the backup destination details, such as 'spaceUtilized,' are updated.
+        """
+elif False:
+    AutonomousContainerDatabaseBackupDestinationPropertiesListArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class AutonomousContainerDatabaseBackupDestinationPropertiesListArgs:
+    def __init__(__self__, *,
+                 backup_destination_attach_histories: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 space_utilized_in_gbs: Optional[pulumi.Input[int]] = None,
+                 time_at_which_storage_details_are_updated: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] backup_destination_attach_histories: The timestamps at which this backup destination is used as the preferred destination to host the Autonomous Container Database backups.
+        :param pulumi.Input[int] space_utilized_in_gbs: The total space utilized (in GBs) by this Autonomous Container Database on this backup destination, rounded to the nearest integer.
+        :param pulumi.Input[str] time_at_which_storage_details_are_updated: The latest timestamp when the backup destination details, such as 'spaceUtilized,' are updated.
+        """
+        if backup_destination_attach_histories is not None:
+            pulumi.set(__self__, "backup_destination_attach_histories", backup_destination_attach_histories)
+        if space_utilized_in_gbs is not None:
+            pulumi.set(__self__, "space_utilized_in_gbs", space_utilized_in_gbs)
+        if time_at_which_storage_details_are_updated is not None:
+            pulumi.set(__self__, "time_at_which_storage_details_are_updated", time_at_which_storage_details_are_updated)
+
+    @property
+    @pulumi.getter(name="backupDestinationAttachHistories")
+    def backup_destination_attach_histories(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        The timestamps at which this backup destination is used as the preferred destination to host the Autonomous Container Database backups.
+        """
+        return pulumi.get(self, "backup_destination_attach_histories")
+
+    @backup_destination_attach_histories.setter
+    def backup_destination_attach_histories(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "backup_destination_attach_histories", value)
+
+    @property
+    @pulumi.getter(name="spaceUtilizedInGbs")
+    def space_utilized_in_gbs(self) -> Optional[pulumi.Input[int]]:
+        """
+        The total space utilized (in GBs) by this Autonomous Container Database on this backup destination, rounded to the nearest integer.
+        """
+        return pulumi.get(self, "space_utilized_in_gbs")
+
+    @space_utilized_in_gbs.setter
+    def space_utilized_in_gbs(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "space_utilized_in_gbs", value)
+
+    @property
+    @pulumi.getter(name="timeAtWhichStorageDetailsAreUpdated")
+    def time_at_which_storage_details_are_updated(self) -> Optional[pulumi.Input[str]]:
+        """
+        The latest timestamp when the backup destination details, such as 'spaceUtilized,' are updated.
+        """
+        return pulumi.get(self, "time_at_which_storage_details_are_updated")
+
+    @time_at_which_storage_details_are_updated.setter
+    def time_at_which_storage_details_are_updated(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "time_at_which_storage_details_are_updated", value)
+
+
 if not MYPY:
     class AutonomousContainerDatabaseDataguardAssociationPeerAutonomousContainerDatabaseBackupConfigArgsDict(TypedDict):
         backup_destination_details: NotRequired[pulumi.Input[Sequence[pulumi.Input['AutonomousContainerDatabaseDataguardAssociationPeerAutonomousContainerDatabaseBackupConfigBackupDestinationDetailArgsDict']]]]
@@ -1762,6 +2068,81 @@ class AutonomousContainerDatabasePeerAutonomousContainerDatabaseBackupConfigBack
         pulumi.set(self, "vpc_user", value)
 
 
+if not MYPY:
+    class AutonomousContainerDatabaseRecoveryApplianceDetailArgsDict(TypedDict):
+        allocated_storage_size_in_gbs: NotRequired[pulumi.Input[int]]
+        """
+        The storage size of the backup destination allocated for an Autonomous Container Database to store backups on the recovery appliance, in GBs, rounded to the nearest integer.
+        """
+        recovery_window_in_days: NotRequired[pulumi.Input[int]]
+        """
+        Number of days between the current and earliest point of recoverability covered by automatic backups.
+        """
+        time_recovery_appliance_details_updated: NotRequired[pulumi.Input[str]]
+        """
+        The time when the recovery appliance details are updated.
+        =======
+        """
+elif False:
+    AutonomousContainerDatabaseRecoveryApplianceDetailArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class AutonomousContainerDatabaseRecoveryApplianceDetailArgs:
+    def __init__(__self__, *,
+                 allocated_storage_size_in_gbs: Optional[pulumi.Input[int]] = None,
+                 recovery_window_in_days: Optional[pulumi.Input[int]] = None,
+                 time_recovery_appliance_details_updated: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[int] allocated_storage_size_in_gbs: The storage size of the backup destination allocated for an Autonomous Container Database to store backups on the recovery appliance, in GBs, rounded to the nearest integer.
+        :param pulumi.Input[int] recovery_window_in_days: Number of days between the current and earliest point of recoverability covered by automatic backups.
+        :param pulumi.Input[str] time_recovery_appliance_details_updated: The time when the recovery appliance details are updated.
+               =======
+        """
+        if allocated_storage_size_in_gbs is not None:
+            pulumi.set(__self__, "allocated_storage_size_in_gbs", allocated_storage_size_in_gbs)
+        if recovery_window_in_days is not None:
+            pulumi.set(__self__, "recovery_window_in_days", recovery_window_in_days)
+        if time_recovery_appliance_details_updated is not None:
+            pulumi.set(__self__, "time_recovery_appliance_details_updated", time_recovery_appliance_details_updated)
+
+    @property
+    @pulumi.getter(name="allocatedStorageSizeInGbs")
+    def allocated_storage_size_in_gbs(self) -> Optional[pulumi.Input[int]]:
+        """
+        The storage size of the backup destination allocated for an Autonomous Container Database to store backups on the recovery appliance, in GBs, rounded to the nearest integer.
+        """
+        return pulumi.get(self, "allocated_storage_size_in_gbs")
+
+    @allocated_storage_size_in_gbs.setter
+    def allocated_storage_size_in_gbs(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "allocated_storage_size_in_gbs", value)
+
+    @property
+    @pulumi.getter(name="recoveryWindowInDays")
+    def recovery_window_in_days(self) -> Optional[pulumi.Input[int]]:
+        """
+        Number of days between the current and earliest point of recoverability covered by automatic backups.
+        """
+        return pulumi.get(self, "recovery_window_in_days")
+
+    @recovery_window_in_days.setter
+    def recovery_window_in_days(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "recovery_window_in_days", value)
+
+    @property
+    @pulumi.getter(name="timeRecoveryApplianceDetailsUpdated")
+    def time_recovery_appliance_details_updated(self) -> Optional[pulumi.Input[str]]:
+        """
+        The time when the recovery appliance details are updated.
+        =======
+        """
+        return pulumi.get(self, "time_recovery_appliance_details_updated")
+
+    @time_recovery_appliance_details_updated.setter
+    def time_recovery_appliance_details_updated(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "time_recovery_appliance_details_updated", value)
+
+
 if not MYPY:
     class AutonomousDatabaseApexDetailArgsDict(TypedDict):
         apex_version: NotRequired[pulumi.Input[str]]
@@ -3338,6 +3719,10 @@ if not MYPY:
         """
         Additional information about the current lifecycle state.
         """
+        maintenance_target_component: NotRequired[pulumi.Input[str]]
+        """
+        The component chosen for maintenance.
+        """
         state: NotRequired[pulumi.Input[str]]
         """
         The current state of the Autonomous Database.
@@ -3350,6 +3735,14 @@ if not MYPY:
         """
         The date and time the Disaster Recovery role was switched for the standby Autonomous Database.
         """
+        time_maintenance_begin: NotRequired[pulumi.Input[str]]
+        """
+        The date and time when maintenance will begin.
+        """
+        time_maintenance_end: NotRequired[pulumi.Input[str]]
+        """
+        The date and time when maintenance will end.
+        """
 elif False:
     AutonomousDatabaseLocalStandbyDbArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -3359,16 +3752,22 @@ class AutonomousDatabaseLocalStandbyDbArgs:
                  availability_domain: Optional[pulumi.Input[str]] = None,
                  lag_time_in_seconds: Optional[pulumi.Input[int]] = None,
                  lifecycle_details: Optional[pulumi.Input[str]] = None,
+                 maintenance_target_component: Optional[pulumi.Input[str]] = None,
                  state: Optional[pulumi.Input[str]] = None,
                  time_data_guard_role_changed: Optional[pulumi.Input[str]] = None,
-                 time_disaster_recovery_role_changed: Optional[pulumi.Input[str]] = None):
+                 time_disaster_recovery_role_changed: Optional[pulumi.Input[str]] = None,
+                 time_maintenance_begin: Optional[pulumi.Input[str]] = None,
+                 time_maintenance_end: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[str] availability_domain: The availability domain of a local Autonomous Data Guard standby database of an Autonomous Database Serverless instance.
         :param pulumi.Input[int] lag_time_in_seconds: The amount of time, in seconds, that the data of the standby database lags the data of the primary database. Can be used to determine the potential data loss in the event of a failover.
         :param pulumi.Input[str] lifecycle_details: Additional information about the current lifecycle state.
+        :param pulumi.Input[str] maintenance_target_component: The component chosen for maintenance.
         :param pulumi.Input[str] state: The current state of the Autonomous Database.
         :param pulumi.Input[str] time_data_guard_role_changed: The date and time the Autonomous Data Guard role was switched for the Autonomous Database. For databases that have standbys in both the primary Data Guard region and a remote Data Guard standby region, this is the latest timestamp of either the database using the "primary" role in the primary Data Guard region, or database located in the remote Data Guard standby region.
         :param pulumi.Input[str] time_disaster_recovery_role_changed: The date and time the Disaster Recovery role was switched for the standby Autonomous Database.
+        :param pulumi.Input[str] time_maintenance_begin: The date and time when maintenance will begin.
+        :param pulumi.Input[str] time_maintenance_end: The date and time when maintenance will end.
         """
         if availability_domain is not None:
             pulumi.set(__self__, "availability_domain", availability_domain)
@@ -3376,12 +3775,18 @@ class AutonomousDatabaseLocalStandbyDbArgs:
             pulumi.set(__self__, "lag_time_in_seconds", lag_time_in_seconds)
         if lifecycle_details is not None:
             pulumi.set(__self__, "lifecycle_details", lifecycle_details)
+        if maintenance_target_component is not None:
+            pulumi.set(__self__, "maintenance_target_component", maintenance_target_component)
         if state is not None:
             pulumi.set(__self__, "state", state)
         if time_data_guard_role_changed is not None:
             pulumi.set(__self__, "time_data_guard_role_changed", time_data_guard_role_changed)
         if time_disaster_recovery_role_changed is not None:
             pulumi.set(__self__, "time_disaster_recovery_role_changed", time_disaster_recovery_role_changed)
+        if time_maintenance_begin is not None:
+            pulumi.set(__self__, "time_maintenance_begin", time_maintenance_begin)
+        if time_maintenance_end is not None:
+            pulumi.set(__self__, "time_maintenance_end", time_maintenance_end)
 
     @property
     @pulumi.getter(name="availabilityDomain")
@@ -3419,6 +3824,18 @@ class AutonomousDatabaseLocalStandbyDbArgs:
     def lifecycle_details(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "lifecycle_details", value)
 
+    @property
+    @pulumi.getter(name="maintenanceTargetComponent")
+    def maintenance_target_component(self) -> Optional[pulumi.Input[str]]:
+        """
+        The component chosen for maintenance.
+        """
+        return pulumi.get(self, "maintenance_target_component")
+
+    @maintenance_target_component.setter
+    def maintenance_target_component(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "maintenance_target_component", value)
+
     @property
     @pulumi.getter
     def state(self) -> Optional[pulumi.Input[str]]:
@@ -3455,14 +3872,38 @@ class AutonomousDatabaseLocalStandbyDbArgs:
     def time_disaster_recovery_role_changed(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "time_disaster_recovery_role_changed", value)
 
-
-if not MYPY:
-    class AutonomousDatabaseLongTermBackupScheduleArgsDict(TypedDict):
-        is_disabled: NotRequired[pulumi.Input[bool]]
-        """
-        Indicates if the long-term backup schedule should be deleted. The default value is `FALSE`.
+    @property
+    @pulumi.getter(name="timeMaintenanceBegin")
+    def time_maintenance_begin(self) -> Optional[pulumi.Input[str]]:
         """
-        repeat_cadence: NotRequired[pulumi.Input[str]]
+        The date and time when maintenance will begin.
+        """
+        return pulumi.get(self, "time_maintenance_begin")
+
+    @time_maintenance_begin.setter
+    def time_maintenance_begin(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "time_maintenance_begin", value)
+
+    @property
+    @pulumi.getter(name="timeMaintenanceEnd")
+    def time_maintenance_end(self) -> Optional[pulumi.Input[str]]:
+        """
+        The date and time when maintenance will end.
+        """
+        return pulumi.get(self, "time_maintenance_end")
+
+    @time_maintenance_end.setter
+    def time_maintenance_end(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "time_maintenance_end", value)
+
+
+if not MYPY:
+    class AutonomousDatabaseLongTermBackupScheduleArgsDict(TypedDict):
+        is_disabled: NotRequired[pulumi.Input[bool]]
+        """
+        Indicates if the long-term backup schedule should be deleted. The default value is `FALSE`.
+        """
+        repeat_cadence: NotRequired[pulumi.Input[str]]
         """
         The frequency of the long-term backup schedule
         """
@@ -3980,6 +4421,10 @@ if not MYPY:
         """
         Additional information about the current lifecycle state.
         """
+        maintenance_target_component: NotRequired[pulumi.Input[str]]
+        """
+        The component chosen for maintenance.
+        """
         state: NotRequired[pulumi.Input[str]]
         """
         The current state of the Autonomous Database.
@@ -3992,6 +4437,14 @@ if not MYPY:
         """
         The date and time the Disaster Recovery role was switched for the standby Autonomous Database.
         """
+        time_maintenance_begin: NotRequired[pulumi.Input[str]]
+        """
+        The date and time when maintenance will begin.
+        """
+        time_maintenance_end: NotRequired[pulumi.Input[str]]
+        """
+        The date and time when maintenance will end.
+        """
 elif False:
     AutonomousDatabaseStandbyDbArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -4001,16 +4454,22 @@ class AutonomousDatabaseStandbyDbArgs:
                  availability_domain: Optional[pulumi.Input[str]] = None,
                  lag_time_in_seconds: Optional[pulumi.Input[int]] = None,
                  lifecycle_details: Optional[pulumi.Input[str]] = None,
+                 maintenance_target_component: Optional[pulumi.Input[str]] = None,
                  state: Optional[pulumi.Input[str]] = None,
                  time_data_guard_role_changed: Optional[pulumi.Input[str]] = None,
-                 time_disaster_recovery_role_changed: Optional[pulumi.Input[str]] = None):
+                 time_disaster_recovery_role_changed: Optional[pulumi.Input[str]] = None,
+                 time_maintenance_begin: Optional[pulumi.Input[str]] = None,
+                 time_maintenance_end: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[str] availability_domain: The availability domain of a local Autonomous Data Guard standby database of an Autonomous Database Serverless instance.
         :param pulumi.Input[int] lag_time_in_seconds: The amount of time, in seconds, that the data of the standby database lags the data of the primary database. Can be used to determine the potential data loss in the event of a failover.
         :param pulumi.Input[str] lifecycle_details: Additional information about the current lifecycle state.
+        :param pulumi.Input[str] maintenance_target_component: The component chosen for maintenance.
         :param pulumi.Input[str] state: The current state of the Autonomous Database.
         :param pulumi.Input[str] time_data_guard_role_changed: The date and time the Autonomous Data Guard role was switched for the Autonomous Database. For databases that have standbys in both the primary Data Guard region and a remote Data Guard standby region, this is the latest timestamp of either the database using the "primary" role in the primary Data Guard region, or database located in the remote Data Guard standby region.
         :param pulumi.Input[str] time_disaster_recovery_role_changed: The date and time the Disaster Recovery role was switched for the standby Autonomous Database.
+        :param pulumi.Input[str] time_maintenance_begin: The date and time when maintenance will begin.
+        :param pulumi.Input[str] time_maintenance_end: The date and time when maintenance will end.
         """
         if availability_domain is not None:
             pulumi.set(__self__, "availability_domain", availability_domain)
@@ -4018,12 +4477,18 @@ class AutonomousDatabaseStandbyDbArgs:
             pulumi.set(__self__, "lag_time_in_seconds", lag_time_in_seconds)
         if lifecycle_details is not None:
             pulumi.set(__self__, "lifecycle_details", lifecycle_details)
+        if maintenance_target_component is not None:
+            pulumi.set(__self__, "maintenance_target_component", maintenance_target_component)
         if state is not None:
             pulumi.set(__self__, "state", state)
         if time_data_guard_role_changed is not None:
             pulumi.set(__self__, "time_data_guard_role_changed", time_data_guard_role_changed)
         if time_disaster_recovery_role_changed is not None:
             pulumi.set(__self__, "time_disaster_recovery_role_changed", time_disaster_recovery_role_changed)
+        if time_maintenance_begin is not None:
+            pulumi.set(__self__, "time_maintenance_begin", time_maintenance_begin)
+        if time_maintenance_end is not None:
+            pulumi.set(__self__, "time_maintenance_end", time_maintenance_end)
 
     @property
     @pulumi.getter(name="availabilityDomain")
@@ -4061,6 +4526,18 @@ class AutonomousDatabaseStandbyDbArgs:
     def lifecycle_details(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "lifecycle_details", value)
 
+    @property
+    @pulumi.getter(name="maintenanceTargetComponent")
+    def maintenance_target_component(self) -> Optional[pulumi.Input[str]]:
+        """
+        The component chosen for maintenance.
+        """
+        return pulumi.get(self, "maintenance_target_component")
+
+    @maintenance_target_component.setter
+    def maintenance_target_component(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "maintenance_target_component", value)
+
     @property
     @pulumi.getter
     def state(self) -> Optional[pulumi.Input[str]]:
@@ -4097,6 +4574,30 @@ class AutonomousDatabaseStandbyDbArgs:
     def time_disaster_recovery_role_changed(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "time_disaster_recovery_role_changed", value)
 
+    @property
+    @pulumi.getter(name="timeMaintenanceBegin")
+    def time_maintenance_begin(self) -> Optional[pulumi.Input[str]]:
+        """
+        The date and time when maintenance will begin.
+        """
+        return pulumi.get(self, "time_maintenance_begin")
+
+    @time_maintenance_begin.setter
+    def time_maintenance_begin(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "time_maintenance_begin", value)
+
+    @property
+    @pulumi.getter(name="timeMaintenanceEnd")
+    def time_maintenance_end(self) -> Optional[pulumi.Input[str]]:
+        """
+        The date and time when maintenance will end.
+        """
+        return pulumi.get(self, "time_maintenance_end")
+
+    @time_maintenance_end.setter
+    def time_maintenance_end(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "time_maintenance_end", value)
+
 
 if not MYPY:
     class AutonomousExadataInfrastructureMaintenanceWindowArgsDict(TypedDict):
@@ -13166,106 +13667,109 @@ class ExadataInfrastructureComputeMaintenanceWindowMonthArgs:
 
 
 if not MYPY:
-    class ExadataInfrastructureContactArgsDict(TypedDict):
-        email: pulumi.Input[str]
+    class ExadataInfrastructureConfigureExascaleManagementContactArgsDict(TypedDict):
+        email: NotRequired[pulumi.Input[str]]
         """
-        (Updatable) The email for the Exadata Infrastructure contact.
+        The email for the Exadata Infrastructure contact.
         """
-        is_primary: pulumi.Input[bool]
+        is_contact_mos_validated: NotRequired[pulumi.Input[bool]]
         """
-        (Updatable) If `true`, this Exadata Infrastructure contact is a primary contact. If `false`, this Exadata Infrastructure is a secondary contact.
+        If `true`, this Exadata Infrastructure contact is a valid My Oracle Support (MOS) contact. If `false`, this Exadata Infrastructure contact is not a valid MOS contact.
         """
-        name: pulumi.Input[str]
+        is_primary: NotRequired[pulumi.Input[bool]]
         """
-        (Updatable) The name of the Exadata Infrastructure contact.
+        If `true`, this Exadata Infrastructure contact is a primary contact. If `false`, this Exadata Infrastructure is a secondary contact.
         """
-        is_contact_mos_validated: NotRequired[pulumi.Input[bool]]
+        name: NotRequired[pulumi.Input[str]]
         """
-        (Updatable) If `true`, this Exadata Infrastructure contact is a valid My Oracle Support (MOS) contact. If `false`, this Exadata Infrastructure contact is not a valid MOS contact.
+        Name of the month of the year.
         """
         phone_number: NotRequired[pulumi.Input[str]]
         """
-        (Updatable) The phone number for the Exadata Infrastructure contact.
+        The phone number for the Exadata Infrastructure contact.
         """
 elif False:
-    ExadataInfrastructureContactArgsDict: TypeAlias = Mapping[str, Any]
+    ExadataInfrastructureConfigureExascaleManagementContactArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class ExadataInfrastructureContactArgs:
+class ExadataInfrastructureConfigureExascaleManagementContactArgs:
     def __init__(__self__, *,
-                 email: pulumi.Input[str],
-                 is_primary: pulumi.Input[bool],
-                 name: pulumi.Input[str],
+                 email: Optional[pulumi.Input[str]] = None,
                  is_contact_mos_validated: Optional[pulumi.Input[bool]] = None,
+                 is_primary: Optional[pulumi.Input[bool]] = None,
+                 name: Optional[pulumi.Input[str]] = None,
                  phone_number: Optional[pulumi.Input[str]] = None):
         """
-        :param pulumi.Input[str] email: (Updatable) The email for the Exadata Infrastructure contact.
-        :param pulumi.Input[bool] is_primary: (Updatable) If `true`, this Exadata Infrastructure contact is a primary contact. If `false`, this Exadata Infrastructure is a secondary contact.
-        :param pulumi.Input[str] name: (Updatable) The name of the Exadata Infrastructure contact.
-        :param pulumi.Input[bool] is_contact_mos_validated: (Updatable) If `true`, this Exadata Infrastructure contact is a valid My Oracle Support (MOS) contact. If `false`, this Exadata Infrastructure contact is not a valid MOS contact.
-        :param pulumi.Input[str] phone_number: (Updatable) The phone number for the Exadata Infrastructure contact.
+        :param pulumi.Input[str] email: The email for the Exadata Infrastructure contact.
+        :param pulumi.Input[bool] is_contact_mos_validated: If `true`, this Exadata Infrastructure contact is a valid My Oracle Support (MOS) contact. If `false`, this Exadata Infrastructure contact is not a valid MOS contact.
+        :param pulumi.Input[bool] is_primary: If `true`, this Exadata Infrastructure contact is a primary contact. If `false`, this Exadata Infrastructure is a secondary contact.
+        :param pulumi.Input[str] name: Name of the month of the year.
+        :param pulumi.Input[str] phone_number: The phone number for the Exadata Infrastructure contact.
         """
-        pulumi.set(__self__, "email", email)
-        pulumi.set(__self__, "is_primary", is_primary)
-        pulumi.set(__self__, "name", name)
+        if email is not None:
+            pulumi.set(__self__, "email", email)
         if is_contact_mos_validated is not None:
             pulumi.set(__self__, "is_contact_mos_validated", is_contact_mos_validated)
+        if is_primary is not None:
+            pulumi.set(__self__, "is_primary", is_primary)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
         if phone_number is not None:
             pulumi.set(__self__, "phone_number", phone_number)
 
     @property
     @pulumi.getter
-    def email(self) -> pulumi.Input[str]:
+    def email(self) -> Optional[pulumi.Input[str]]:
         """
-        (Updatable) The email for the Exadata Infrastructure contact.
+        The email for the Exadata Infrastructure contact.
         """
         return pulumi.get(self, "email")
 
     @email.setter
-    def email(self, value: pulumi.Input[str]):
+    def email(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "email", value)
 
+    @property
+    @pulumi.getter(name="isContactMosValidated")
+    def is_contact_mos_validated(self) -> Optional[pulumi.Input[bool]]:
+        """
+        If `true`, this Exadata Infrastructure contact is a valid My Oracle Support (MOS) contact. If `false`, this Exadata Infrastructure contact is not a valid MOS contact.
+        """
+        return pulumi.get(self, "is_contact_mos_validated")
+
+    @is_contact_mos_validated.setter
+    def is_contact_mos_validated(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "is_contact_mos_validated", value)
+
     @property
     @pulumi.getter(name="isPrimary")
-    def is_primary(self) -> pulumi.Input[bool]:
+    def is_primary(self) -> Optional[pulumi.Input[bool]]:
         """
-        (Updatable) If `true`, this Exadata Infrastructure contact is a primary contact. If `false`, this Exadata Infrastructure is a secondary contact.
+        If `true`, this Exadata Infrastructure contact is a primary contact. If `false`, this Exadata Infrastructure is a secondary contact.
         """
         return pulumi.get(self, "is_primary")
 
     @is_primary.setter
-    def is_primary(self, value: pulumi.Input[bool]):
+    def is_primary(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "is_primary", value)
 
     @property
     @pulumi.getter
-    def name(self) -> pulumi.Input[str]:
+    def name(self) -> Optional[pulumi.Input[str]]:
         """
-        (Updatable) The name of the Exadata Infrastructure contact.
+        Name of the month of the year.
         """
         return pulumi.get(self, "name")
 
     @name.setter
-    def name(self, value: pulumi.Input[str]):
+    def name(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "name", value)
 
-    @property
-    @pulumi.getter(name="isContactMosValidated")
-    def is_contact_mos_validated(self) -> Optional[pulumi.Input[bool]]:
-        """
-        (Updatable) If `true`, this Exadata Infrastructure contact is a valid My Oracle Support (MOS) contact. If `false`, this Exadata Infrastructure contact is not a valid MOS contact.
-        """
-        return pulumi.get(self, "is_contact_mos_validated")
-
-    @is_contact_mos_validated.setter
-    def is_contact_mos_validated(self, value: Optional[pulumi.Input[bool]]):
-        pulumi.set(self, "is_contact_mos_validated", value)
-
     @property
     @pulumi.getter(name="phoneNumber")
     def phone_number(self) -> Optional[pulumi.Input[str]]:
         """
-        (Updatable) The phone number for the Exadata Infrastructure contact.
+        The phone number for the Exadata Infrastructure contact.
         """
         return pulumi.get(self, "phone_number")
 
@@ -13275,7 +13779,7 @@ class ExadataInfrastructureContactArgs:
 
 
 if not MYPY:
-    class ExadataInfrastructureDefinedFileSystemConfigurationArgsDict(TypedDict):
+    class ExadataInfrastructureConfigureExascaleManagementDefinedFileSystemConfigurationArgsDict(TypedDict):
         is_backup_partition: NotRequired[pulumi.Input[bool]]
         """
         If true, the file system is used to create a backup prior to Exadata VM OS update.
@@ -13293,10 +13797,10 @@ if not MYPY:
         The mount point of file system.
         """
 elif False:
-    ExadataInfrastructureDefinedFileSystemConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+    ExadataInfrastructureConfigureExascaleManagementDefinedFileSystemConfigurationArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class ExadataInfrastructureDefinedFileSystemConfigurationArgs:
+class ExadataInfrastructureConfigureExascaleManagementDefinedFileSystemConfigurationArgs:
     def __init__(__self__, *,
                  is_backup_partition: Optional[pulumi.Input[bool]] = None,
                  is_resizable: Optional[pulumi.Input[bool]] = None,
@@ -13366,6 +13870,691 @@ class ExadataInfrastructureDefinedFileSystemConfigurationArgs:
         pulumi.set(self, "mount_point", value)
 
 
+if not MYPY:
+    class ExadataInfrastructureConfigureExascaleManagementExascaleConfigArgsDict(TypedDict):
+        available_storage_in_gbs: NotRequired[pulumi.Input[int]]
+        """
+        Available storage size for Exascale in GBs.
+        """
+        total_storage_in_gbs: NotRequired[pulumi.Input[int]]
+        """
+        Storage size needed for Exascale in GBs.
+
+
+        ** 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
+        """
+elif False:
+    ExadataInfrastructureConfigureExascaleManagementExascaleConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ExadataInfrastructureConfigureExascaleManagementExascaleConfigArgs:
+    def __init__(__self__, *,
+                 available_storage_in_gbs: Optional[pulumi.Input[int]] = None,
+                 total_storage_in_gbs: Optional[pulumi.Input[int]] = None):
+        """
+        :param pulumi.Input[int] available_storage_in_gbs: Available storage size for Exascale in GBs.
+        :param pulumi.Input[int] total_storage_in_gbs: Storage size needed for Exascale in GBs.
+               
+               
+               ** 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
+        """
+        if available_storage_in_gbs is not None:
+            pulumi.set(__self__, "available_storage_in_gbs", available_storage_in_gbs)
+        if total_storage_in_gbs is not None:
+            pulumi.set(__self__, "total_storage_in_gbs", total_storage_in_gbs)
+
+    @property
+    @pulumi.getter(name="availableStorageInGbs")
+    def available_storage_in_gbs(self) -> Optional[pulumi.Input[int]]:
+        """
+        Available storage size for Exascale in GBs.
+        """
+        return pulumi.get(self, "available_storage_in_gbs")
+
+    @available_storage_in_gbs.setter
+    def available_storage_in_gbs(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "available_storage_in_gbs", value)
+
+    @property
+    @pulumi.getter(name="totalStorageInGbs")
+    def total_storage_in_gbs(self) -> Optional[pulumi.Input[int]]:
+        """
+        Storage size needed for Exascale in GBs.
+
+
+        ** 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, "total_storage_in_gbs")
+
+    @total_storage_in_gbs.setter
+    def total_storage_in_gbs(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "total_storage_in_gbs", value)
+
+
+if not MYPY:
+    class ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowArgsDict(TypedDict):
+        custom_action_timeout_in_mins: NotRequired[pulumi.Input[int]]
+        """
+        Determines the amount of time the system will wait before the start of each database server patching operation. Custom action timeout is in minutes and valid value is between 15 to 120 (inclusive).
+        """
+        days_of_weeks: NotRequired[pulumi.Input[Sequence[pulumi.Input['ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowDaysOfWeekArgsDict']]]]
+        """
+        Days during the week when maintenance should be performed.
+        """
+        hours_of_days: NotRequired[pulumi.Input[Sequence[pulumi.Input[int]]]]
+        """
+        The window of hours during the day when maintenance should be performed. The window is a 4 hour slot. Valid values are - 0 - represents time slot 0:00 - 3:59 UTC - 4 - represents time slot 4:00 - 7:59 UTC - 8 - represents time slot 8:00 - 11:59 UTC - 12 - represents time slot 12:00 - 15:59 UTC - 16 - represents time slot 16:00 - 19:59 UTC - 20 - represents time slot 20:00 - 23:59 UTC
+        """
+        is_custom_action_timeout_enabled: NotRequired[pulumi.Input[bool]]
+        """
+        If true, enables the configuration of a custom action timeout (waiting period) between database server patching operations.
+        """
+        is_monthly_patching_enabled: NotRequired[pulumi.Input[bool]]
+        """
+        If true, enables the monthly patching option.
+        """
+        lead_time_in_weeks: NotRequired[pulumi.Input[int]]
+        """
+        Lead time window allows user to set a lead time to prepare for a down time. The lead time is in weeks and valid value is between 1 to 4.
+        """
+        months: NotRequired[pulumi.Input[Sequence[pulumi.Input['ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowMonthArgsDict']]]]
+        """
+        Months during the year when maintenance should be performed.
+        """
+        patching_mode: NotRequired[pulumi.Input[str]]
+        """
+        Cloud Exadata infrastructure node patching method, either "ROLLING" or "NONROLLING". Default value is ROLLING.
+        """
+        preference: NotRequired[pulumi.Input[str]]
+        """
+        The maintenance window scheduling preference.
+        """
+        skip_rus: NotRequired[pulumi.Input[Sequence[pulumi.Input[bool]]]]
+        """
+        If true, skips the release update (RU) for the quarter. You cannot skip two consecutive quarters. An RU skip request will only be honoured if the current version of the Autonomous Container Database is supported for current quarter.
+        """
+        weeks_of_months: NotRequired[pulumi.Input[Sequence[pulumi.Input[int]]]]
+        """
+        Weeks during the month when maintenance should be performed. Weeks start on the 1st, 8th, 15th, and 22nd days of the month, and have a duration of 7 days. Weeks start and end based on calendar dates, not days of the week. For example, to allow maintenance during the 2nd week of the month (from the 8th day to the 14th day of the month), use the value 2. Maintenance cannot be scheduled for the fifth week of months that contain more than 28 days. Note that this parameter works in conjunction with the  daysOfWeek and hoursOfDay parameters to allow you to specify specific days of the week and hours that maintenance will be performed.
+        """
+elif False:
+    ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowArgs:
+    def __init__(__self__, *,
+                 custom_action_timeout_in_mins: Optional[pulumi.Input[int]] = None,
+                 days_of_weeks: Optional[pulumi.Input[Sequence[pulumi.Input['ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowDaysOfWeekArgs']]]] = None,
+                 hours_of_days: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
+                 is_custom_action_timeout_enabled: Optional[pulumi.Input[bool]] = None,
+                 is_monthly_patching_enabled: Optional[pulumi.Input[bool]] = None,
+                 lead_time_in_weeks: Optional[pulumi.Input[int]] = None,
+                 months: Optional[pulumi.Input[Sequence[pulumi.Input['ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowMonthArgs']]]] = None,
+                 patching_mode: Optional[pulumi.Input[str]] = None,
+                 preference: Optional[pulumi.Input[str]] = None,
+                 skip_rus: Optional[pulumi.Input[Sequence[pulumi.Input[bool]]]] = None,
+                 weeks_of_months: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None):
+        """
+        :param pulumi.Input[int] custom_action_timeout_in_mins: Determines the amount of time the system will wait before the start of each database server patching operation. Custom action timeout is in minutes and valid value is between 15 to 120 (inclusive).
+        :param pulumi.Input[Sequence[pulumi.Input['ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowDaysOfWeekArgs']]] days_of_weeks: Days during the week when maintenance should be performed.
+        :param pulumi.Input[Sequence[pulumi.Input[int]]] hours_of_days: The window of hours during the day when maintenance should be performed. The window is a 4 hour slot. Valid values are - 0 - represents time slot 0:00 - 3:59 UTC - 4 - represents time slot 4:00 - 7:59 UTC - 8 - represents time slot 8:00 - 11:59 UTC - 12 - represents time slot 12:00 - 15:59 UTC - 16 - represents time slot 16:00 - 19:59 UTC - 20 - represents time slot 20:00 - 23:59 UTC
+        :param pulumi.Input[bool] is_custom_action_timeout_enabled: If true, enables the configuration of a custom action timeout (waiting period) between database server patching operations.
+        :param pulumi.Input[bool] is_monthly_patching_enabled: If true, enables the monthly patching option.
+        :param pulumi.Input[int] lead_time_in_weeks: Lead time window allows user to set a lead time to prepare for a down time. The lead time is in weeks and valid value is between 1 to 4.
+        :param pulumi.Input[Sequence[pulumi.Input['ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowMonthArgs']]] months: Months during the year when maintenance should be performed.
+        :param pulumi.Input[str] patching_mode: Cloud Exadata infrastructure node patching method, either "ROLLING" or "NONROLLING". Default value is ROLLING.
+        :param pulumi.Input[str] preference: The maintenance window scheduling preference.
+        :param pulumi.Input[Sequence[pulumi.Input[bool]]] skip_rus: If true, skips the release update (RU) for the quarter. You cannot skip two consecutive quarters. An RU skip request will only be honoured if the current version of the Autonomous Container Database is supported for current quarter.
+        :param pulumi.Input[Sequence[pulumi.Input[int]]] weeks_of_months: Weeks during the month when maintenance should be performed. Weeks start on the 1st, 8th, 15th, and 22nd days of the month, and have a duration of 7 days. Weeks start and end based on calendar dates, not days of the week. For example, to allow maintenance during the 2nd week of the month (from the 8th day to the 14th day of the month), use the value 2. Maintenance cannot be scheduled for the fifth week of months that contain more than 28 days. Note that this parameter works in conjunction with the  daysOfWeek and hoursOfDay parameters to allow you to specify specific days of the week and hours that maintenance will be performed.
+        """
+        if custom_action_timeout_in_mins is not None:
+            pulumi.set(__self__, "custom_action_timeout_in_mins", custom_action_timeout_in_mins)
+        if days_of_weeks is not None:
+            pulumi.set(__self__, "days_of_weeks", days_of_weeks)
+        if hours_of_days is not None:
+            pulumi.set(__self__, "hours_of_days", hours_of_days)
+        if is_custom_action_timeout_enabled is not None:
+            pulumi.set(__self__, "is_custom_action_timeout_enabled", is_custom_action_timeout_enabled)
+        if is_monthly_patching_enabled is not None:
+            pulumi.set(__self__, "is_monthly_patching_enabled", is_monthly_patching_enabled)
+        if lead_time_in_weeks is not None:
+            pulumi.set(__self__, "lead_time_in_weeks", lead_time_in_weeks)
+        if months is not None:
+            pulumi.set(__self__, "months", months)
+        if patching_mode is not None:
+            pulumi.set(__self__, "patching_mode", patching_mode)
+        if preference is not None:
+            pulumi.set(__self__, "preference", preference)
+        if skip_rus is not None:
+            pulumi.set(__self__, "skip_rus", skip_rus)
+        if weeks_of_months is not None:
+            pulumi.set(__self__, "weeks_of_months", weeks_of_months)
+
+    @property
+    @pulumi.getter(name="customActionTimeoutInMins")
+    def custom_action_timeout_in_mins(self) -> Optional[pulumi.Input[int]]:
+        """
+        Determines the amount of time the system will wait before the start of each database server patching operation. Custom action timeout is in minutes and valid value is between 15 to 120 (inclusive).
+        """
+        return pulumi.get(self, "custom_action_timeout_in_mins")
+
+    @custom_action_timeout_in_mins.setter
+    def custom_action_timeout_in_mins(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "custom_action_timeout_in_mins", value)
+
+    @property
+    @pulumi.getter(name="daysOfWeeks")
+    def days_of_weeks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowDaysOfWeekArgs']]]]:
+        """
+        Days during the week when maintenance should be performed.
+        """
+        return pulumi.get(self, "days_of_weeks")
+
+    @days_of_weeks.setter
+    def days_of_weeks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowDaysOfWeekArgs']]]]):
+        pulumi.set(self, "days_of_weeks", value)
+
+    @property
+    @pulumi.getter(name="hoursOfDays")
+    def hours_of_days(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
+        """
+        The window of hours during the day when maintenance should be performed. The window is a 4 hour slot. Valid values are - 0 - represents time slot 0:00 - 3:59 UTC - 4 - represents time slot 4:00 - 7:59 UTC - 8 - represents time slot 8:00 - 11:59 UTC - 12 - represents time slot 12:00 - 15:59 UTC - 16 - represents time slot 16:00 - 19:59 UTC - 20 - represents time slot 20:00 - 23:59 UTC
+        """
+        return pulumi.get(self, "hours_of_days")
+
+    @hours_of_days.setter
+    def hours_of_days(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
+        pulumi.set(self, "hours_of_days", value)
+
+    @property
+    @pulumi.getter(name="isCustomActionTimeoutEnabled")
+    def is_custom_action_timeout_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        If true, enables the configuration of a custom action timeout (waiting period) between database server patching operations.
+        """
+        return pulumi.get(self, "is_custom_action_timeout_enabled")
+
+    @is_custom_action_timeout_enabled.setter
+    def is_custom_action_timeout_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "is_custom_action_timeout_enabled", value)
+
+    @property
+    @pulumi.getter(name="isMonthlyPatchingEnabled")
+    def is_monthly_patching_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        If true, enables the monthly patching option.
+        """
+        return pulumi.get(self, "is_monthly_patching_enabled")
+
+    @is_monthly_patching_enabled.setter
+    def is_monthly_patching_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "is_monthly_patching_enabled", value)
+
+    @property
+    @pulumi.getter(name="leadTimeInWeeks")
+    def lead_time_in_weeks(self) -> Optional[pulumi.Input[int]]:
+        """
+        Lead time window allows user to set a lead time to prepare for a down time. The lead time is in weeks and valid value is between 1 to 4.
+        """
+        return pulumi.get(self, "lead_time_in_weeks")
+
+    @lead_time_in_weeks.setter
+    def lead_time_in_weeks(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "lead_time_in_weeks", value)
+
+    @property
+    @pulumi.getter
+    def months(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowMonthArgs']]]]:
+        """
+        Months during the year when maintenance should be performed.
+        """
+        return pulumi.get(self, "months")
+
+    @months.setter
+    def months(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowMonthArgs']]]]):
+        pulumi.set(self, "months", value)
+
+    @property
+    @pulumi.getter(name="patchingMode")
+    def patching_mode(self) -> Optional[pulumi.Input[str]]:
+        """
+        Cloud Exadata infrastructure node patching method, either "ROLLING" or "NONROLLING". Default value is ROLLING.
+        """
+        return pulumi.get(self, "patching_mode")
+
+    @patching_mode.setter
+    def patching_mode(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "patching_mode", value)
+
+    @property
+    @pulumi.getter
+    def preference(self) -> Optional[pulumi.Input[str]]:
+        """
+        The maintenance window scheduling preference.
+        """
+        return pulumi.get(self, "preference")
+
+    @preference.setter
+    def preference(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "preference", value)
+
+    @property
+    @pulumi.getter(name="skipRus")
+    def skip_rus(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[bool]]]]:
+        """
+        If true, skips the release update (RU) for the quarter. You cannot skip two consecutive quarters. An RU skip request will only be honoured if the current version of the Autonomous Container Database is supported for current quarter.
+        """
+        return pulumi.get(self, "skip_rus")
+
+    @skip_rus.setter
+    def skip_rus(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[bool]]]]):
+        pulumi.set(self, "skip_rus", value)
+
+    @property
+    @pulumi.getter(name="weeksOfMonths")
+    def weeks_of_months(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
+        """
+        Weeks during the month when maintenance should be performed. Weeks start on the 1st, 8th, 15th, and 22nd days of the month, and have a duration of 7 days. Weeks start and end based on calendar dates, not days of the week. For example, to allow maintenance during the 2nd week of the month (from the 8th day to the 14th day of the month), use the value 2. Maintenance cannot be scheduled for the fifth week of months that contain more than 28 days. Note that this parameter works in conjunction with the  daysOfWeek and hoursOfDay parameters to allow you to specify specific days of the week and hours that maintenance will be performed.
+        """
+        return pulumi.get(self, "weeks_of_months")
+
+    @weeks_of_months.setter
+    def weeks_of_months(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
+        pulumi.set(self, "weeks_of_months", value)
+
+
+if not MYPY:
+    class ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowDaysOfWeekArgsDict(TypedDict):
+        name: NotRequired[pulumi.Input[str]]
+        """
+        Name of the month of the year.
+        """
+elif False:
+    ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowDaysOfWeekArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowDaysOfWeekArgs:
+    def __init__(__self__, *,
+                 name: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] name: Name of the month of the year.
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Name of the month of the year.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "name", value)
+
+
+if not MYPY:
+    class ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowMonthArgsDict(TypedDict):
+        name: NotRequired[pulumi.Input[str]]
+        """
+        Name of the month of the year.
+        """
+elif False:
+    ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowMonthArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ExadataInfrastructureConfigureExascaleManagementMaintenanceWindowMonthArgs:
+    def __init__(__self__, *,
+                 name: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] name: Name of the month of the year.
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Name of the month of the year.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "name", value)
+
+
+if not MYPY:
+    class ExadataInfrastructureConfigureExascaleManagementNetworkBondingModeDetailArgsDict(TypedDict):
+        backup_network_bonding_mode: NotRequired[pulumi.Input[str]]
+        """
+        The network bonding mode for the Exadata infrastructure.
+        """
+        client_network_bonding_mode: NotRequired[pulumi.Input[str]]
+        """
+        The network bonding mode for the Exadata infrastructure.
+        """
+        dr_network_bonding_mode: NotRequired[pulumi.Input[str]]
+        """
+        The network bonding mode for the Exadata infrastructure.
+        """
+elif False:
+    ExadataInfrastructureConfigureExascaleManagementNetworkBondingModeDetailArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ExadataInfrastructureConfigureExascaleManagementNetworkBondingModeDetailArgs:
+    def __init__(__self__, *,
+                 backup_network_bonding_mode: Optional[pulumi.Input[str]] = None,
+                 client_network_bonding_mode: Optional[pulumi.Input[str]] = None,
+                 dr_network_bonding_mode: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] backup_network_bonding_mode: The network bonding mode for the Exadata infrastructure.
+        :param pulumi.Input[str] client_network_bonding_mode: The network bonding mode for the Exadata infrastructure.
+        :param pulumi.Input[str] dr_network_bonding_mode: The network bonding mode for the Exadata infrastructure.
+        """
+        if backup_network_bonding_mode is not None:
+            pulumi.set(__self__, "backup_network_bonding_mode", backup_network_bonding_mode)
+        if client_network_bonding_mode is not None:
+            pulumi.set(__self__, "client_network_bonding_mode", client_network_bonding_mode)
+        if dr_network_bonding_mode is not None:
+            pulumi.set(__self__, "dr_network_bonding_mode", dr_network_bonding_mode)
+
+    @property
+    @pulumi.getter(name="backupNetworkBondingMode")
+    def backup_network_bonding_mode(self) -> Optional[pulumi.Input[str]]:
+        """
+        The network bonding mode for the Exadata infrastructure.
+        """
+        return pulumi.get(self, "backup_network_bonding_mode")
+
+    @backup_network_bonding_mode.setter
+    def backup_network_bonding_mode(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "backup_network_bonding_mode", value)
+
+    @property
+    @pulumi.getter(name="clientNetworkBondingMode")
+    def client_network_bonding_mode(self) -> Optional[pulumi.Input[str]]:
+        """
+        The network bonding mode for the Exadata infrastructure.
+        """
+        return pulumi.get(self, "client_network_bonding_mode")
+
+    @client_network_bonding_mode.setter
+    def client_network_bonding_mode(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "client_network_bonding_mode", value)
+
+    @property
+    @pulumi.getter(name="drNetworkBondingMode")
+    def dr_network_bonding_mode(self) -> Optional[pulumi.Input[str]]:
+        """
+        The network bonding mode for the Exadata infrastructure.
+        """
+        return pulumi.get(self, "dr_network_bonding_mode")
+
+    @dr_network_bonding_mode.setter
+    def dr_network_bonding_mode(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "dr_network_bonding_mode", value)
+
+
+if not MYPY:
+    class ExadataInfrastructureContactArgsDict(TypedDict):
+        email: pulumi.Input[str]
+        """
+        (Updatable) The email for the Exadata Infrastructure contact.
+        """
+        is_primary: pulumi.Input[bool]
+        """
+        (Updatable) If `true`, this Exadata Infrastructure contact is a primary contact. If `false`, this Exadata Infrastructure is a secondary contact.
+        """
+        name: pulumi.Input[str]
+        """
+        (Updatable) The name of the Exadata Infrastructure contact.
+        """
+        is_contact_mos_validated: NotRequired[pulumi.Input[bool]]
+        """
+        (Updatable) If `true`, this Exadata Infrastructure contact is a valid My Oracle Support (MOS) contact. If `false`, this Exadata Infrastructure contact is not a valid MOS contact.
+        """
+        phone_number: NotRequired[pulumi.Input[str]]
+        """
+        (Updatable) The phone number for the Exadata Infrastructure contact.
+        """
+elif False:
+    ExadataInfrastructureContactArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ExadataInfrastructureContactArgs:
+    def __init__(__self__, *,
+                 email: pulumi.Input[str],
+                 is_primary: pulumi.Input[bool],
+                 name: pulumi.Input[str],
+                 is_contact_mos_validated: Optional[pulumi.Input[bool]] = None,
+                 phone_number: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] email: (Updatable) The email for the Exadata Infrastructure contact.
+        :param pulumi.Input[bool] is_primary: (Updatable) If `true`, this Exadata Infrastructure contact is a primary contact. If `false`, this Exadata Infrastructure is a secondary contact.
+        :param pulumi.Input[str] name: (Updatable) The name of the Exadata Infrastructure contact.
+        :param pulumi.Input[bool] is_contact_mos_validated: (Updatable) If `true`, this Exadata Infrastructure contact is a valid My Oracle Support (MOS) contact. If `false`, this Exadata Infrastructure contact is not a valid MOS contact.
+        :param pulumi.Input[str] phone_number: (Updatable) The phone number for the Exadata Infrastructure contact.
+        """
+        pulumi.set(__self__, "email", email)
+        pulumi.set(__self__, "is_primary", is_primary)
+        pulumi.set(__self__, "name", name)
+        if is_contact_mos_validated is not None:
+            pulumi.set(__self__, "is_contact_mos_validated", is_contact_mos_validated)
+        if phone_number is not None:
+            pulumi.set(__self__, "phone_number", phone_number)
+
+    @property
+    @pulumi.getter
+    def email(self) -> pulumi.Input[str]:
+        """
+        (Updatable) The email for the Exadata Infrastructure contact.
+        """
+        return pulumi.get(self, "email")
+
+    @email.setter
+    def email(self, value: pulumi.Input[str]):
+        pulumi.set(self, "email", value)
+
+    @property
+    @pulumi.getter(name="isPrimary")
+    def is_primary(self) -> pulumi.Input[bool]:
+        """
+        (Updatable) If `true`, this Exadata Infrastructure contact is a primary contact. If `false`, this Exadata Infrastructure is a secondary contact.
+        """
+        return pulumi.get(self, "is_primary")
+
+    @is_primary.setter
+    def is_primary(self, value: pulumi.Input[bool]):
+        pulumi.set(self, "is_primary", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[str]:
+        """
+        (Updatable) The name of the Exadata Infrastructure contact.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter(name="isContactMosValidated")
+    def is_contact_mos_validated(self) -> Optional[pulumi.Input[bool]]:
+        """
+        (Updatable) If `true`, this Exadata Infrastructure contact is a valid My Oracle Support (MOS) contact. If `false`, this Exadata Infrastructure contact is not a valid MOS contact.
+        """
+        return pulumi.get(self, "is_contact_mos_validated")
+
+    @is_contact_mos_validated.setter
+    def is_contact_mos_validated(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "is_contact_mos_validated", value)
+
+    @property
+    @pulumi.getter(name="phoneNumber")
+    def phone_number(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Updatable) The phone number for the Exadata Infrastructure contact.
+        """
+        return pulumi.get(self, "phone_number")
+
+    @phone_number.setter
+    def phone_number(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "phone_number", value)
+
+
+if not MYPY:
+    class ExadataInfrastructureDefinedFileSystemConfigurationArgsDict(TypedDict):
+        is_backup_partition: NotRequired[pulumi.Input[bool]]
+        """
+        If true, the file system is used to create a backup prior to Exadata VM OS update.
+        """
+        is_resizable: NotRequired[pulumi.Input[bool]]
+        """
+        If true, the file system resize is allowed for the Exadata Infrastructure cluster. If false, the file system resize is not allowed.
+        """
+        min_size_gb: NotRequired[pulumi.Input[int]]
+        """
+        The minimum size of file system.
+        """
+        mount_point: NotRequired[pulumi.Input[str]]
+        """
+        The mount point of file system.
+        """
+elif False:
+    ExadataInfrastructureDefinedFileSystemConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ExadataInfrastructureDefinedFileSystemConfigurationArgs:
+    def __init__(__self__, *,
+                 is_backup_partition: Optional[pulumi.Input[bool]] = None,
+                 is_resizable: Optional[pulumi.Input[bool]] = None,
+                 min_size_gb: Optional[pulumi.Input[int]] = None,
+                 mount_point: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[bool] is_backup_partition: If true, the file system is used to create a backup prior to Exadata VM OS update.
+        :param pulumi.Input[bool] is_resizable: If true, the file system resize is allowed for the Exadata Infrastructure cluster. If false, the file system resize is not allowed.
+        :param pulumi.Input[int] min_size_gb: The minimum size of file system.
+        :param pulumi.Input[str] mount_point: The mount point of file system.
+        """
+        if is_backup_partition is not None:
+            pulumi.set(__self__, "is_backup_partition", is_backup_partition)
+        if is_resizable is not None:
+            pulumi.set(__self__, "is_resizable", is_resizable)
+        if min_size_gb is not None:
+            pulumi.set(__self__, "min_size_gb", min_size_gb)
+        if mount_point is not None:
+            pulumi.set(__self__, "mount_point", mount_point)
+
+    @property
+    @pulumi.getter(name="isBackupPartition")
+    def is_backup_partition(self) -> Optional[pulumi.Input[bool]]:
+        """
+        If true, the file system is used to create a backup prior to Exadata VM OS update.
+        """
+        return pulumi.get(self, "is_backup_partition")
+
+    @is_backup_partition.setter
+    def is_backup_partition(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "is_backup_partition", value)
+
+    @property
+    @pulumi.getter(name="isResizable")
+    def is_resizable(self) -> Optional[pulumi.Input[bool]]:
+        """
+        If true, the file system resize is allowed for the Exadata Infrastructure cluster. If false, the file system resize is not allowed.
+        """
+        return pulumi.get(self, "is_resizable")
+
+    @is_resizable.setter
+    def is_resizable(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "is_resizable", value)
+
+    @property
+    @pulumi.getter(name="minSizeGb")
+    def min_size_gb(self) -> Optional[pulumi.Input[int]]:
+        """
+        The minimum size of file system.
+        """
+        return pulumi.get(self, "min_size_gb")
+
+    @min_size_gb.setter
+    def min_size_gb(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "min_size_gb", value)
+
+    @property
+    @pulumi.getter(name="mountPoint")
+    def mount_point(self) -> Optional[pulumi.Input[str]]:
+        """
+        The mount point of file system.
+        """
+        return pulumi.get(self, "mount_point")
+
+    @mount_point.setter
+    def mount_point(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "mount_point", value)
+
+
+if not MYPY:
+    class ExadataInfrastructureExascaleConfigArgsDict(TypedDict):
+        available_storage_in_gbs: NotRequired[pulumi.Input[int]]
+        """
+        Available storage size for Exascale in GBs.
+        """
+        total_storage_in_gbs: NotRequired[pulumi.Input[int]]
+        """
+        Storage size needed for Exascale in GBs.
+        """
+elif False:
+    ExadataInfrastructureExascaleConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ExadataInfrastructureExascaleConfigArgs:
+    def __init__(__self__, *,
+                 available_storage_in_gbs: Optional[pulumi.Input[int]] = None,
+                 total_storage_in_gbs: Optional[pulumi.Input[int]] = None):
+        """
+        :param pulumi.Input[int] available_storage_in_gbs: Available storage size for Exascale in GBs.
+        :param pulumi.Input[int] total_storage_in_gbs: Storage size needed for Exascale in GBs.
+        """
+        if available_storage_in_gbs is not None:
+            pulumi.set(__self__, "available_storage_in_gbs", available_storage_in_gbs)
+        if total_storage_in_gbs is not None:
+            pulumi.set(__self__, "total_storage_in_gbs", total_storage_in_gbs)
+
+    @property
+    @pulumi.getter(name="availableStorageInGbs")
+    def available_storage_in_gbs(self) -> Optional[pulumi.Input[int]]:
+        """
+        Available storage size for Exascale in GBs.
+        """
+        return pulumi.get(self, "available_storage_in_gbs")
+
+    @available_storage_in_gbs.setter
+    def available_storage_in_gbs(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "available_storage_in_gbs", value)
+
+    @property
+    @pulumi.getter(name="totalStorageInGbs")
+    def total_storage_in_gbs(self) -> Optional[pulumi.Input[int]]:
+        """
+        Storage size needed for Exascale in GBs.
+        """
+        return pulumi.get(self, "total_storage_in_gbs")
+
+    @total_storage_in_gbs.setter
+    def total_storage_in_gbs(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "total_storage_in_gbs", value)
+
+
 if not MYPY:
     class ExadataInfrastructureMaintenanceWindowArgsDict(TypedDict):
         custom_action_timeout_in_mins: NotRequired[pulumi.Input[int]]