pulumi-oci 3.5.0a1756363728__py3-none-any.whl → 3.6.0a1756509375__py3-none-any.whl

pulumi_oci/database/_inputs.py

@@ -205,10 +205,14 @@ __all__ = [
     'DatabaseDatabaseManagementConfigArgsDict',
     'DatabaseDatabaseSourceEncryptionKeyLocationDetailsArgs',
     'DatabaseDatabaseSourceEncryptionKeyLocationDetailsArgsDict',
+    'DatabaseDatabaseStorageSizeDetailsArgs',
+    'DatabaseDatabaseStorageSizeDetailsArgsDict',
     'DatabaseDbBackupConfigArgs',
     'DatabaseDbBackupConfigArgsDict',
     'DatabaseDbBackupConfigBackupDestinationDetailArgs',
     'DatabaseDbBackupConfigBackupDestinationDetailArgsDict',
+    'DatabaseStorageSizeDetailArgs',
+    'DatabaseStorageSizeDetailArgsDict',
     'DatabaseUpgradeConnectionStringArgs',
     'DatabaseUpgradeConnectionStringArgsDict',
     'DatabaseUpgradeDataGuardGroupArgs',
@@ -231,6 +235,8 @@ __all__ = [
     'DbHomeDatabaseDbBackupConfigBackupDestinationDetailArgsDict',
     'DbHomeDatabaseEncryptionKeyLocationDetailsArgs',
     'DbHomeDatabaseEncryptionKeyLocationDetailsArgsDict',
+    'DbHomeDatabaseStorageSizeDetailsArgs',
+    'DbHomeDatabaseStorageSizeDetailsArgsDict',
     'DbSystemDataCollectionOptionsArgs',
     'DbSystemDataCollectionOptionsArgsDict',
     'DbSystemDbHomeArgs',
@@ -10540,6 +10546,10 @@ if not MYPY:
         """
         The TDE wallet password of the source database specified by 'sourceDatabaseId'.
         """
+        storage_size_details: NotRequired[pulumi.Input['DatabaseDatabaseStorageSizeDetailsArgsDict']]
+        """
+        The database storage size details. This database option is supported for the Exadata VM cluster on Exascale Infrastructure.
+        """
         tde_wallet_password: NotRequired[pulumi.Input[_builtins.str]]
         """
         The optional password to open the TDE wallet. The password must be at least nine characters and contain at least two uppercase, two lowercase, two numeric, and two special characters. The special characters must be _, \\#, or -.
@@ -10589,6 +10599,7 @@ class DatabaseDatabaseArgs:
                  source_database_id: Optional[pulumi.Input[_builtins.str]] = None,
                  source_encryption_key_location_details: Optional[pulumi.Input['DatabaseDatabaseSourceEncryptionKeyLocationDetailsArgs']] = None,
                  source_tde_wallet_password: Optional[pulumi.Input[_builtins.str]] = None,
+                 storage_size_details: Optional[pulumi.Input['DatabaseDatabaseStorageSizeDetailsArgs']] = None,
                  tde_wallet_password: Optional[pulumi.Input[_builtins.str]] = None,
                  transport_type: Optional[pulumi.Input[_builtins.str]] = None,
                  vault_id: Optional[pulumi.Input[_builtins.str]] = None):
@@ -10623,6 +10634,7 @@ class DatabaseDatabaseArgs:
         :param pulumi.Input[_builtins.str] source_database_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the source database.
         :param pulumi.Input['DatabaseDatabaseSourceEncryptionKeyLocationDetailsArgs'] source_encryption_key_location_details: Types of providers supported for managing database encryption keys
         :param pulumi.Input[_builtins.str] source_tde_wallet_password: The TDE wallet password of the source database specified by 'sourceDatabaseId'.
+        :param pulumi.Input['DatabaseDatabaseStorageSizeDetailsArgs'] storage_size_details: The database storage size details. This database option is supported for the Exadata VM cluster on Exascale Infrastructure.
         :param pulumi.Input[_builtins.str] tde_wallet_password: The optional password to open the TDE wallet. The password must be at least nine characters and contain at least two uppercase, two lowercase, two numeric, and two special characters. The special characters must be _, \\#, or -.
         :param pulumi.Input[_builtins.str] transport_type: The redo transport type to use for this Data Guard association.  Valid values depend on the specified `protectionMode`:
                * MAXIMUM_AVAILABILITY - SYNC or FASTSYNC
@@ -10682,6 +10694,8 @@ class DatabaseDatabaseArgs:
             pulumi.set(__self__, "source_encryption_key_location_details", source_encryption_key_location_details)
         if source_tde_wallet_password is not None:
             pulumi.set(__self__, "source_tde_wallet_password", source_tde_wallet_password)
+        if storage_size_details is not None:
+            pulumi.set(__self__, "storage_size_details", storage_size_details)
         if tde_wallet_password is not None:
             pulumi.set(__self__, "tde_wallet_password", tde_wallet_password)
         if transport_type is not None:
@@ -10983,6 +10997,18 @@ class DatabaseDatabaseArgs:
     def source_tde_wallet_password(self, value: Optional[pulumi.Input[_builtins.str]]):
         pulumi.set(self, "source_tde_wallet_password", value)
 
+    @_builtins.property
+    @pulumi.getter(name="storageSizeDetails")
+    def storage_size_details(self) -> Optional[pulumi.Input['DatabaseDatabaseStorageSizeDetailsArgs']]:
+        """
+        The database storage size details. This database option is supported for the Exadata VM cluster on Exascale Infrastructure.
+        """
+        return pulumi.get(self, "storage_size_details")
+
+    @storage_size_details.setter
+    def storage_size_details(self, value: Optional[pulumi.Input['DatabaseDatabaseStorageSizeDetailsArgs']]):
+        pulumi.set(self, "storage_size_details", value)
+
     @_builtins.property
     @pulumi.getter(name="tdeWalletPassword")
     def tde_wallet_password(self) -> Optional[pulumi.Input[_builtins.str]]:
@@ -11530,6 +11556,76 @@ class DatabaseDatabaseSourceEncryptionKeyLocationDetailsArgs:
         pulumi.set(self, "provider_type", value)
 
 
+if not MYPY:
+    class DatabaseDatabaseStorageSizeDetailsArgsDict(TypedDict):
+        data_storage_size_in_gb: pulumi.Input[_builtins.int]
+        """
+        (Updatable) The DATA storage size, in gigabytes, that is applicable for the database.
+        """
+        reco_storage_size_in_gbs: pulumi.Input[_builtins.int]
+        """
+        (Updatable) The RECO storage size, in gigabytes, that is applicable for the database.
+        """
+        redo_log_storage_size_in_gbs: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The REDO Log storage size, in gigabytes, that is applicable for the database.
+        """
+elif False:
+    DatabaseDatabaseStorageSizeDetailsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DatabaseDatabaseStorageSizeDetailsArgs:
+    def __init__(__self__, *,
+                 data_storage_size_in_gb: pulumi.Input[_builtins.int],
+                 reco_storage_size_in_gbs: pulumi.Input[_builtins.int],
+                 redo_log_storage_size_in_gbs: Optional[pulumi.Input[_builtins.int]] = None):
+        """
+        :param pulumi.Input[_builtins.int] data_storage_size_in_gb: (Updatable) The DATA storage size, in gigabytes, that is applicable for the database.
+        :param pulumi.Input[_builtins.int] reco_storage_size_in_gbs: (Updatable) The RECO storage size, in gigabytes, that is applicable for the database.
+        :param pulumi.Input[_builtins.int] redo_log_storage_size_in_gbs: The REDO Log storage size, in gigabytes, that is applicable for the database.
+        """
+        pulumi.set(__self__, "data_storage_size_in_gb", data_storage_size_in_gb)
+        pulumi.set(__self__, "reco_storage_size_in_gbs", reco_storage_size_in_gbs)
+        if redo_log_storage_size_in_gbs is not None:
+            pulumi.set(__self__, "redo_log_storage_size_in_gbs", redo_log_storage_size_in_gbs)
+
+    @_builtins.property
+    @pulumi.getter(name="dataStorageSizeInGb")
+    def data_storage_size_in_gb(self) -> pulumi.Input[_builtins.int]:
+        """
+        (Updatable) The DATA storage size, in gigabytes, that is applicable for the database.
+        """
+        return pulumi.get(self, "data_storage_size_in_gb")
+
+    @data_storage_size_in_gb.setter
+    def data_storage_size_in_gb(self, value: pulumi.Input[_builtins.int]):
+        pulumi.set(self, "data_storage_size_in_gb", value)
+
+    @_builtins.property
+    @pulumi.getter(name="recoStorageSizeInGbs")
+    def reco_storage_size_in_gbs(self) -> pulumi.Input[_builtins.int]:
+        """
+        (Updatable) The RECO storage size, in gigabytes, that is applicable for the database.
+        """
+        return pulumi.get(self, "reco_storage_size_in_gbs")
+
+    @reco_storage_size_in_gbs.setter
+    def reco_storage_size_in_gbs(self, value: pulumi.Input[_builtins.int]):
+        pulumi.set(self, "reco_storage_size_in_gbs", value)
+
+    @_builtins.property
+    @pulumi.getter(name="redoLogStorageSizeInGbs")
+    def redo_log_storage_size_in_gbs(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The REDO Log storage size, in gigabytes, that is applicable for the database.
+        """
+        return pulumi.get(self, "redo_log_storage_size_in_gbs")
+
+    @redo_log_storage_size_in_gbs.setter
+    def redo_log_storage_size_in_gbs(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "redo_log_storage_size_in_gbs", value)
+
+
 if not MYPY:
     class DatabaseDbBackupConfigArgsDict(TypedDict):
         auto_backup_enabled: NotRequired[pulumi.Input[_builtins.bool]]
@@ -11854,6 +11950,78 @@ class DatabaseDbBackupConfigBackupDestinationDetailArgs:
         pulumi.set(self, "vpc_user", value)
 
 
+if not MYPY:
+    class DatabaseStorageSizeDetailArgsDict(TypedDict):
+        data_storage_size_in_gb: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The DATA storage size, in gigabytes, that is applicable for the database.
+        """
+        reco_storage_size_in_gbs: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The RECO storage size, in gigabytes, that is applicable for the database.
+        """
+        redo_log_storage_size_in_gbs: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The REDO Log storage size, in gigabytes, that is applicable for the database.
+        """
+elif False:
+    DatabaseStorageSizeDetailArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DatabaseStorageSizeDetailArgs:
+    def __init__(__self__, *,
+                 data_storage_size_in_gb: Optional[pulumi.Input[_builtins.int]] = None,
+                 reco_storage_size_in_gbs: Optional[pulumi.Input[_builtins.int]] = None,
+                 redo_log_storage_size_in_gbs: Optional[pulumi.Input[_builtins.int]] = None):
+        """
+        :param pulumi.Input[_builtins.int] data_storage_size_in_gb: The DATA storage size, in gigabytes, that is applicable for the database.
+        :param pulumi.Input[_builtins.int] reco_storage_size_in_gbs: The RECO storage size, in gigabytes, that is applicable for the database.
+        :param pulumi.Input[_builtins.int] redo_log_storage_size_in_gbs: The REDO Log storage size, in gigabytes, that is applicable for the database.
+        """
+        if data_storage_size_in_gb is not None:
+            pulumi.set(__self__, "data_storage_size_in_gb", data_storage_size_in_gb)
+        if reco_storage_size_in_gbs is not None:
+            pulumi.set(__self__, "reco_storage_size_in_gbs", reco_storage_size_in_gbs)
+        if redo_log_storage_size_in_gbs is not None:
+            pulumi.set(__self__, "redo_log_storage_size_in_gbs", redo_log_storage_size_in_gbs)
+
+    @_builtins.property
+    @pulumi.getter(name="dataStorageSizeInGb")
+    def data_storage_size_in_gb(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The DATA storage size, in gigabytes, that is applicable for the database.
+        """
+        return pulumi.get(self, "data_storage_size_in_gb")
+
+    @data_storage_size_in_gb.setter
+    def data_storage_size_in_gb(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "data_storage_size_in_gb", value)
+
+    @_builtins.property
+    @pulumi.getter(name="recoStorageSizeInGbs")
+    def reco_storage_size_in_gbs(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The RECO storage size, in gigabytes, that is applicable for the database.
+        """
+        return pulumi.get(self, "reco_storage_size_in_gbs")
+
+    @reco_storage_size_in_gbs.setter
+    def reco_storage_size_in_gbs(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "reco_storage_size_in_gbs", value)
+
+    @_builtins.property
+    @pulumi.getter(name="redoLogStorageSizeInGbs")
+    def redo_log_storage_size_in_gbs(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The REDO Log storage size, in gigabytes, that is applicable for the database.
+        """
+        return pulumi.get(self, "redo_log_storage_size_in_gbs")
+
+    @redo_log_storage_size_in_gbs.setter
+    def redo_log_storage_size_in_gbs(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "redo_log_storage_size_in_gbs", value)
+
+
 if not MYPY:
     class DatabaseUpgradeConnectionStringArgsDict(TypedDict):
         all_connection_strings: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
@@ -12739,6 +12907,10 @@ if not MYPY:
         """
         The current state of the Database Home.
         """
+        storage_size_details: NotRequired[pulumi.Input['DbHomeDatabaseStorageSizeDetailsArgsDict']]
+        """
+        The database storage size details. This database option is supported for the Exadata VM cluster on Exascale Infrastructure.
+        """
         tde_wallet_password: NotRequired[pulumi.Input[_builtins.str]]
         """
         The optional password to open the TDE wallet. The password must be at least nine characters and contain at least two uppercase, two lowercase, two numeric, and two special characters. The special characters must be _, \\#, or -.
@@ -12786,6 +12958,7 @@ class DbHomeDatabaseArgs:
                  pluggable_databases: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                  sid_prefix: Optional[pulumi.Input[_builtins.str]] = None,
                  state: Optional[pulumi.Input[_builtins.str]] = None,
+                 storage_size_details: Optional[pulumi.Input['DbHomeDatabaseStorageSizeDetailsArgs']] = None,
                  tde_wallet_password: Optional[pulumi.Input[_builtins.str]] = None,
                  time_created: Optional[pulumi.Input[_builtins.str]] = None,
                  time_stamp_for_point_in_time_recovery: Optional[pulumi.Input[_builtins.str]] = None,
@@ -12818,6 +12991,7 @@ class DbHomeDatabaseArgs:
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] pluggable_databases: The list of pluggable databases that needs to be restored into new database.
         :param pulumi.Input[_builtins.str] sid_prefix: Specifies a prefix for the `Oracle SID` of the database to be created.
         :param pulumi.Input[_builtins.str] state: The current state of the Database Home.
+        :param pulumi.Input['DbHomeDatabaseStorageSizeDetailsArgs'] storage_size_details: The database storage size details. This database option is supported for the Exadata VM cluster on Exascale Infrastructure.
         :param pulumi.Input[_builtins.str] tde_wallet_password: The optional password to open the TDE wallet. The password must be at least nine characters and contain at least two uppercase, two lowercase, two numeric, and two special characters. The special characters must be _, \\#, or -.
         :param pulumi.Input[_builtins.str] time_created: The date and time the Database Home was created.
         :param pulumi.Input[_builtins.str] time_stamp_for_point_in_time_recovery: The point in time of the original database from which the new database is created. If not specifed, the latest backup is used to create the database.
@@ -12872,6 +13046,8 @@ class DbHomeDatabaseArgs:
             pulumi.set(__self__, "sid_prefix", sid_prefix)
         if state is not None:
             pulumi.set(__self__, "state", state)
+        if storage_size_details is not None:
+            pulumi.set(__self__, "storage_size_details", storage_size_details)
         if tde_wallet_password is not None:
             pulumi.set(__self__, "tde_wallet_password", tde_wallet_password)
         if time_created is not None:
@@ -13179,6 +13355,18 @@ class DbHomeDatabaseArgs:
     def state(self, value: Optional[pulumi.Input[_builtins.str]]):
         pulumi.set(self, "state", value)
 
+    @_builtins.property
+    @pulumi.getter(name="storageSizeDetails")
+    def storage_size_details(self) -> Optional[pulumi.Input['DbHomeDatabaseStorageSizeDetailsArgs']]:
+        """
+        The database storage size details. This database option is supported for the Exadata VM cluster on Exascale Infrastructure.
+        """
+        return pulumi.get(self, "storage_size_details")
+
+    @storage_size_details.setter
+    def storage_size_details(self, value: Optional[pulumi.Input['DbHomeDatabaseStorageSizeDetailsArgs']]):
+        pulumi.set(self, "storage_size_details", value)
+
     @_builtins.property
     @pulumi.getter(name="tdeWalletPassword")
     def tde_wallet_password(self) -> Optional[pulumi.Input[_builtins.str]]:
@@ -13664,6 +13852,69 @@ class DbHomeDatabaseEncryptionKeyLocationDetailsArgs:
         pulumi.set(self, "hsm_password", value)
 
 
+if not MYPY:
+    class DbHomeDatabaseStorageSizeDetailsArgsDict(TypedDict):
+        data_storage_size_in_gb: pulumi.Input[_builtins.int]
+        """
+        The DATA storage size, in gigabytes, that is applicable for the database.
+        """
+        reco_storage_size_in_gbs: pulumi.Input[_builtins.int]
+        """
+        The RECO storage size, in gigabytes, that is applicable for the database.
+        """
+        redo_log_storage_size_in_gbs: NotRequired[pulumi.Input[_builtins.int]]
+elif False:
+    DbHomeDatabaseStorageSizeDetailsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DbHomeDatabaseStorageSizeDetailsArgs:
+    def __init__(__self__, *,
+                 data_storage_size_in_gb: pulumi.Input[_builtins.int],
+                 reco_storage_size_in_gbs: pulumi.Input[_builtins.int],
+                 redo_log_storage_size_in_gbs: Optional[pulumi.Input[_builtins.int]] = None):
+        """
+        :param pulumi.Input[_builtins.int] data_storage_size_in_gb: The DATA storage size, in gigabytes, that is applicable for the database.
+        :param pulumi.Input[_builtins.int] reco_storage_size_in_gbs: The RECO storage size, in gigabytes, that is applicable for the database.
+        """
+        pulumi.set(__self__, "data_storage_size_in_gb", data_storage_size_in_gb)
+        pulumi.set(__self__, "reco_storage_size_in_gbs", reco_storage_size_in_gbs)
+        if redo_log_storage_size_in_gbs is not None:
+            pulumi.set(__self__, "redo_log_storage_size_in_gbs", redo_log_storage_size_in_gbs)
+
+    @_builtins.property
+    @pulumi.getter(name="dataStorageSizeInGb")
+    def data_storage_size_in_gb(self) -> pulumi.Input[_builtins.int]:
+        """
+        The DATA storage size, in gigabytes, that is applicable for the database.
+        """
+        return pulumi.get(self, "data_storage_size_in_gb")
+
+    @data_storage_size_in_gb.setter
+    def data_storage_size_in_gb(self, value: pulumi.Input[_builtins.int]):
+        pulumi.set(self, "data_storage_size_in_gb", value)
+
+    @_builtins.property
+    @pulumi.getter(name="recoStorageSizeInGbs")
+    def reco_storage_size_in_gbs(self) -> pulumi.Input[_builtins.int]:
+        """
+        The RECO storage size, in gigabytes, that is applicable for the database.
+        """
+        return pulumi.get(self, "reco_storage_size_in_gbs")
+
+    @reco_storage_size_in_gbs.setter
+    def reco_storage_size_in_gbs(self, value: pulumi.Input[_builtins.int]):
+        pulumi.set(self, "reco_storage_size_in_gbs", value)
+
+    @_builtins.property
+    @pulumi.getter(name="redoLogStorageSizeInGbs")
+    def redo_log_storage_size_in_gbs(self) -> Optional[pulumi.Input[_builtins.int]]:
+        return pulumi.get(self, "redo_log_storage_size_in_gbs")
+
+    @redo_log_storage_size_in_gbs.setter
+    def redo_log_storage_size_in_gbs(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "redo_log_storage_size_in_gbs", value)
+
+
 if not MYPY:
     class DbSystemDataCollectionOptionsArgsDict(TypedDict):
         is_diagnostics_events_enabled: NotRequired[pulumi.Input[_builtins.bool]]
@@ -14794,13 +15045,11 @@ if not MYPY:
         """
         is_remote: NotRequired[pulumi.Input[_builtins.bool]]
         """
-        Indicates whether the backup destination is cross-region or local region.
+        Indicates whether the backup destination is cross-region or local.
         """
         remote_region: NotRequired[pulumi.Input[_builtins.str]]
         """
-        The name of the remote region where the remote automatic incremental backups will be stored.
-
-        For information about valid region names, see [Regions and Availability Domains](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/regions.htm).
+        The name of the remote region where the remote automatic incremental backups will be stored.           For information about valid region names, see [Regions and Availability Domains](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/regions.htm).
         """
         type: NotRequired[pulumi.Input[_builtins.str]]
         """
@@ -14820,10 +15069,8 @@ class DbSystemDbHomeDatabaseDbBackupConfigBackupDestinationDetailArgs:
         """
         :param pulumi.Input[_builtins.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[_builtins.str] id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the backup destination.
-        :param pulumi.Input[_builtins.bool] is_remote: Indicates whether the backup destination is cross-region or local region.
-        :param pulumi.Input[_builtins.str] remote_region: The name of the remote region where the remote automatic incremental backups will be stored.
-               
-               For information about valid region names, see [Regions and Availability Domains](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/regions.htm).
+        :param pulumi.Input[_builtins.bool] is_remote: Indicates whether the backup destination is cross-region or local.
+        :param pulumi.Input[_builtins.str] remote_region: The name of the remote region where the remote automatic incremental backups will be stored.           For information about valid region names, see [Regions and Availability Domains](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/regions.htm).
         :param pulumi.Input[_builtins.str] type: Type of the database backup destination.
         """
         if dbrs_policy_id is not None:
@@ -14865,7 +15112,7 @@ class DbSystemDbHomeDatabaseDbBackupConfigBackupDestinationDetailArgs:
     @pulumi.getter(name="isRemote")
     def is_remote(self) -> Optional[pulumi.Input[_builtins.bool]]:
         """
-        Indicates whether the backup destination is cross-region or local region.
+        Indicates whether the backup destination is cross-region or local.
         """
         return pulumi.get(self, "is_remote")
 
@@ -14877,9 +15124,7 @@ class DbSystemDbHomeDatabaseDbBackupConfigBackupDestinationDetailArgs:
     @pulumi.getter(name="remoteRegion")
     def remote_region(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        The name of the remote region where the remote automatic incremental backups will be stored.
-
-        For information about valid region names, see [Regions and Availability Domains](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/regions.htm).
+        The name of the remote region where the remote automatic incremental backups will be stored.           For information about valid region names, see [Regions and Availability Domains](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/regions.htm).
         """
         return pulumi.get(self, "remote_region")
 

pulumi_oci/database/data_guard_association.py

@@ -29,6 +29,8 @@ class DataGuardAssociationArgs:
                  transport_type: pulumi.Input[_builtins.str],
                  availability_domain: Optional[pulumi.Input[_builtins.str]] = None,
                  backup_network_nsg_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
+                 compute_count: Optional[pulumi.Input[_builtins.int]] = None,
+                 compute_model: Optional[pulumi.Input[_builtins.str]] = None,
                  cpu_core_count: Optional[pulumi.Input[_builtins.int]] = None,
                  create_async: Optional[pulumi.Input[_builtins.bool]] = None,
                  data_collection_options: Optional[pulumi.Input['DataGuardAssociationDataCollectionOptionsArgs']] = None,
@@ -84,6 +86,8 @@ class DataGuardAssociationArgs:
                **IMPORTANT** - The only transport type currently supported by the Database service is ASYNC.
         :param pulumi.Input[_builtins.str] availability_domain: The name of the availability domain that the standby database DB system will be located in. For example- "Uocm:PHX-AD-1".
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] backup_network_nsg_ids: A list of the [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network security groups (NSGs) that the backup network of this DB system belongs to. Setting this to an empty array after the list is created removes the resource from all NSGs. For more information about NSGs, see [Security Rules](https://docs.cloud.oracle.com/iaas/Content/Network/Concepts/securityrules.htm). Applicable only to Exadata systems.
+        :param pulumi.Input[_builtins.int] compute_count: The number of compute servers for the DB system.
+        :param pulumi.Input[_builtins.str] compute_model: The compute model for Base Database Service. This is required if using the `computeCount` parameter. If using `cpuCoreCount` then it is an error to specify `computeModel` to a non-null value. The ECPU compute model is the recommended model, and the OCPU compute model is legacy.
         :param pulumi.Input[_builtins.int] cpu_core_count: The number of CPU cores available for AMD-based virtual machine DB systems.
         :param pulumi.Input['DataGuardAssociationDataCollectionOptionsArgs'] data_collection_options: Indicates user preferences for the various diagnostic collection options for the VM cluster/Cloud VM cluster/VMBM DBCS.
         :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] database_defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm).
@@ -141,6 +145,10 @@ class DataGuardAssociationArgs:
             pulumi.set(__self__, "availability_domain", availability_domain)
         if backup_network_nsg_ids is not None:
             pulumi.set(__self__, "backup_network_nsg_ids", backup_network_nsg_ids)
+        if compute_count is not None:
+            pulumi.set(__self__, "compute_count", compute_count)
+        if compute_model is not None:
+            pulumi.set(__self__, "compute_model", compute_model)
         if cpu_core_count is not None:
             pulumi.set(__self__, "cpu_core_count", cpu_core_count)
         if create_async is not None:
@@ -310,6 +318,30 @@ class DataGuardAssociationArgs:
     def backup_network_nsg_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
         pulumi.set(self, "backup_network_nsg_ids", value)
 
+    @_builtins.property
+    @pulumi.getter(name="computeCount")
+    def compute_count(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The number of compute servers for the DB system.
+        """
+        return pulumi.get(self, "compute_count")
+
+    @compute_count.setter
+    def compute_count(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "compute_count", value)
+
+    @_builtins.property
+    @pulumi.getter(name="computeModel")
+    def compute_model(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The compute model for Base Database Service. This is required if using the `computeCount` parameter. If using `cpuCoreCount` then it is an error to specify `computeModel` to a non-null value. The ECPU compute model is the recommended model, and the OCPU compute model is legacy.
+        """
+        return pulumi.get(self, "compute_model")
+
+    @compute_model.setter
+    def compute_model(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "compute_model", value)
+
     @_builtins.property
     @pulumi.getter(name="cpuCoreCount")
     def cpu_core_count(self) -> Optional[pulumi.Input[_builtins.int]]:
@@ -681,6 +713,8 @@ class _DataGuardAssociationState:
                  apply_rate: Optional[pulumi.Input[_builtins.str]] = None,
                  availability_domain: Optional[pulumi.Input[_builtins.str]] = None,
                  backup_network_nsg_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
+                 compute_count: Optional[pulumi.Input[_builtins.int]] = None,
+                 compute_model: Optional[pulumi.Input[_builtins.str]] = None,
                  cpu_core_count: Optional[pulumi.Input[_builtins.int]] = None,
                  create_async: Optional[pulumi.Input[_builtins.bool]] = None,
                  creation_type: Optional[pulumi.Input[_builtins.str]] = None,
@@ -729,6 +763,8 @@ class _DataGuardAssociationState:
         :param pulumi.Input[_builtins.str] apply_rate: The rate at which redo logs are synced between the associated databases.  Example: `180 Mb per second`
         :param pulumi.Input[_builtins.str] availability_domain: The name of the availability domain that the standby database DB system will be located in. For example- "Uocm:PHX-AD-1".
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] backup_network_nsg_ids: A list of the [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network security groups (NSGs) that the backup network of this DB system belongs to. Setting this to an empty array after the list is created removes the resource from all NSGs. For more information about NSGs, see [Security Rules](https://docs.cloud.oracle.com/iaas/Content/Network/Concepts/securityrules.htm). Applicable only to Exadata systems.
+        :param pulumi.Input[_builtins.int] compute_count: The number of compute servers for the DB system.
+        :param pulumi.Input[_builtins.str] compute_model: The compute model for Base Database Service. This is required if using the `computeCount` parameter. If using `cpuCoreCount` then it is an error to specify `computeModel` to a non-null value. The ECPU compute model is the recommended model, and the OCPU compute model is legacy.
         :param pulumi.Input[_builtins.int] cpu_core_count: The number of CPU cores available for AMD-based virtual machine DB systems.
         :param pulumi.Input[_builtins.str] creation_type: Specifies whether to create the peer database in an existing DB system or in a new DB system.
         :param pulumi.Input['DataGuardAssociationDataCollectionOptionsArgs'] data_collection_options: Indicates user preferences for the various diagnostic collection options for the VM cluster/Cloud VM cluster/VMBM DBCS.
@@ -813,6 +849,10 @@ class _DataGuardAssociationState:
             pulumi.set(__self__, "availability_domain", availability_domain)
         if backup_network_nsg_ids is not None:
             pulumi.set(__self__, "backup_network_nsg_ids", backup_network_nsg_ids)
+        if compute_count is not None:
+            pulumi.set(__self__, "compute_count", compute_count)
+        if compute_model is not None:
+            pulumi.set(__self__, "compute_model", compute_model)
         if cpu_core_count is not None:
             pulumi.set(__self__, "cpu_core_count", cpu_core_count)
         if create_async is not None:
@@ -946,6 +986,30 @@ class _DataGuardAssociationState:
     def backup_network_nsg_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
         pulumi.set(self, "backup_network_nsg_ids", value)
 
+    @_builtins.property
+    @pulumi.getter(name="computeCount")
+    def compute_count(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The number of compute servers for the DB system.
+        """
+        return pulumi.get(self, "compute_count")
+
+    @compute_count.setter
+    def compute_count(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "compute_count", value)
+
+    @_builtins.property
+    @pulumi.getter(name="computeModel")
+    def compute_model(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The compute model for Base Database Service. This is required if using the `computeCount` parameter. If using `cpuCoreCount` then it is an error to specify `computeModel` to a non-null value. The ECPU compute model is the recommended model, and the OCPU compute model is legacy.
+        """
+        return pulumi.get(self, "compute_model")
+
+    @compute_model.setter
+    def compute_model(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "compute_model", value)
+
     @_builtins.property
     @pulumi.getter(name="cpuCoreCount")
     def cpu_core_count(self) -> Optional[pulumi.Input[_builtins.int]]:
@@ -1488,6 +1552,8 @@ class DataGuardAssociation(pulumi.CustomResource):
                  opts: Optional[pulumi.ResourceOptions] = None,
                  availability_domain: Optional[pulumi.Input[_builtins.str]] = None,
                  backup_network_nsg_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
+                 compute_count: Optional[pulumi.Input[_builtins.int]] = None,
+                 compute_model: Optional[pulumi.Input[_builtins.str]] = None,
                  cpu_core_count: Optional[pulumi.Input[_builtins.int]] = None,
                  create_async: Optional[pulumi.Input[_builtins.bool]] = None,
                  creation_type: Optional[pulumi.Input[_builtins.str]] = None,
@@ -1551,6 +1617,8 @@ class DataGuardAssociation(pulumi.CustomResource):
             transport_type=data_guard_association_transport_type,
             availability_domain=data_guard_association_availability_domain,
             backup_network_nsg_ids=data_guard_association_backup_network_nsg_ids,
+            compute_count=data_guard_association_compute_count,
+            compute_model=data_guard_association_compute_model,
             cpu_core_count=data_guard_association_cpu_core_count,
             database_defined_tags=data_guard_association_database_defined_tags,
             database_freeform_tags=data_guard_association_database_freeform_tags,
@@ -1592,6 +1660,8 @@ class DataGuardAssociation(pulumi.CustomResource):
         :param pulumi.ResourceOptions opts: Options for the resource.
         :param pulumi.Input[_builtins.str] availability_domain: The name of the availability domain that the standby database DB system will be located in. For example- "Uocm:PHX-AD-1".
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] backup_network_nsg_ids: A list of the [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network security groups (NSGs) that the backup network of this DB system belongs to. Setting this to an empty array after the list is created removes the resource from all NSGs. For more information about NSGs, see [Security Rules](https://docs.cloud.oracle.com/iaas/Content/Network/Concepts/securityrules.htm). Applicable only to Exadata systems.
+        :param pulumi.Input[_builtins.int] compute_count: The number of compute servers for the DB system.
+        :param pulumi.Input[_builtins.str] compute_model: The compute model for Base Database Service. This is required if using the `computeCount` parameter. If using `cpuCoreCount` then it is an error to specify `computeModel` to a non-null value. The ECPU compute model is the recommended model, and the OCPU compute model is legacy.
         :param pulumi.Input[_builtins.int] cpu_core_count: The number of CPU cores available for AMD-based virtual machine DB systems.
         :param pulumi.Input[_builtins.str] creation_type: Specifies whether to create the peer database in an existing DB system or in a new DB system.
         :param pulumi.Input[Union['DataGuardAssociationDataCollectionOptionsArgs', 'DataGuardAssociationDataCollectionOptionsArgsDict']] data_collection_options: Indicates user preferences for the various diagnostic collection options for the VM cluster/Cloud VM cluster/VMBM DBCS.
@@ -1694,6 +1764,8 @@ class DataGuardAssociation(pulumi.CustomResource):
             transport_type=data_guard_association_transport_type,
             availability_domain=data_guard_association_availability_domain,
             backup_network_nsg_ids=data_guard_association_backup_network_nsg_ids,
+            compute_count=data_guard_association_compute_count,
+            compute_model=data_guard_association_compute_model,
             cpu_core_count=data_guard_association_cpu_core_count,
             database_defined_tags=data_guard_association_database_defined_tags,
             database_freeform_tags=data_guard_association_database_freeform_tags,
@@ -1748,6 +1820,8 @@ class DataGuardAssociation(pulumi.CustomResource):
                  opts: Optional[pulumi.ResourceOptions] = None,
                  availability_domain: Optional[pulumi.Input[_builtins.str]] = None,
                  backup_network_nsg_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
+                 compute_count: Optional[pulumi.Input[_builtins.int]] = None,
+                 compute_model: Optional[pulumi.Input[_builtins.str]] = None,
                  cpu_core_count: Optional[pulumi.Input[_builtins.int]] = None,
                  create_async: Optional[pulumi.Input[_builtins.bool]] = None,
                  creation_type: Optional[pulumi.Input[_builtins.str]] = None,
@@ -1794,6 +1868,8 @@ class DataGuardAssociation(pulumi.CustomResource):
 
             __props__.__dict__["availability_domain"] = availability_domain
             __props__.__dict__["backup_network_nsg_ids"] = backup_network_nsg_ids
+            __props__.__dict__["compute_count"] = compute_count
+            __props__.__dict__["compute_model"] = compute_model
             __props__.__dict__["cpu_core_count"] = cpu_core_count
             __props__.__dict__["create_async"] = create_async
             if creation_type is None and not opts.urn:
@@ -1866,6 +1942,8 @@ class DataGuardAssociation(pulumi.CustomResource):
             apply_rate: Optional[pulumi.Input[_builtins.str]] = None,
             availability_domain: Optional[pulumi.Input[_builtins.str]] = None,
             backup_network_nsg_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
+            compute_count: Optional[pulumi.Input[_builtins.int]] = None,
+            compute_model: Optional[pulumi.Input[_builtins.str]] = None,
             cpu_core_count: Optional[pulumi.Input[_builtins.int]] = None,
             create_async: Optional[pulumi.Input[_builtins.bool]] = None,
             creation_type: Optional[pulumi.Input[_builtins.str]] = None,
@@ -1919,6 +1997,8 @@ class DataGuardAssociation(pulumi.CustomResource):
         :param pulumi.Input[_builtins.str] apply_rate: The rate at which redo logs are synced between the associated databases.  Example: `180 Mb per second`
         :param pulumi.Input[_builtins.str] availability_domain: The name of the availability domain that the standby database DB system will be located in. For example- "Uocm:PHX-AD-1".
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] backup_network_nsg_ids: A list of the [OCIDs](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network security groups (NSGs) that the backup network of this DB system belongs to. Setting this to an empty array after the list is created removes the resource from all NSGs. For more information about NSGs, see [Security Rules](https://docs.cloud.oracle.com/iaas/Content/Network/Concepts/securityrules.htm). Applicable only to Exadata systems.
+        :param pulumi.Input[_builtins.int] compute_count: The number of compute servers for the DB system.
+        :param pulumi.Input[_builtins.str] compute_model: The compute model for Base Database Service. This is required if using the `computeCount` parameter. If using `cpuCoreCount` then it is an error to specify `computeModel` to a non-null value. The ECPU compute model is the recommended model, and the OCPU compute model is legacy.
         :param pulumi.Input[_builtins.int] cpu_core_count: The number of CPU cores available for AMD-based virtual machine DB systems.
         :param pulumi.Input[_builtins.str] creation_type: Specifies whether to create the peer database in an existing DB system or in a new DB system.
         :param pulumi.Input[Union['DataGuardAssociationDataCollectionOptionsArgs', 'DataGuardAssociationDataCollectionOptionsArgsDict']] data_collection_options: Indicates user preferences for the various diagnostic collection options for the VM cluster/Cloud VM cluster/VMBM DBCS.
@@ -2003,6 +2083,8 @@ class DataGuardAssociation(pulumi.CustomResource):
         __props__.__dict__["apply_rate"] = apply_rate
         __props__.__dict__["availability_domain"] = availability_domain
         __props__.__dict__["backup_network_nsg_ids"] = backup_network_nsg_ids
+        __props__.__dict__["compute_count"] = compute_count
+        __props__.__dict__["compute_model"] = compute_model
         __props__.__dict__["cpu_core_count"] = cpu_core_count
         __props__.__dict__["create_async"] = create_async
         __props__.__dict__["creation_type"] = creation_type
@@ -2079,6 +2161,22 @@ class DataGuardAssociation(pulumi.CustomResource):
         """
         return pulumi.get(self, "backup_network_nsg_ids")
 
+    @_builtins.property
+    @pulumi.getter(name="computeCount")
+    def compute_count(self) -> pulumi.Output[_builtins.int]:
+        """
+        The number of compute servers for the DB system.
+        """
+        return pulumi.get(self, "compute_count")
+
+    @_builtins.property
+    @pulumi.getter(name="computeModel")
+    def compute_model(self) -> pulumi.Output[_builtins.str]:
+        """
+        The compute model for Base Database Service. This is required if using the `computeCount` parameter. If using `cpuCoreCount` then it is an error to specify `computeModel` to a non-null value. The ECPU compute model is the recommended model, and the OCPU compute model is legacy.
+        """
+        return pulumi.get(self, "compute_model")
+
     @_builtins.property
     @pulumi.getter(name="cpuCoreCount")
     def cpu_core_count(self) -> pulumi.Output[_builtins.int]: