pulumi-oci 2.4.0__py3-none-any.whl → 2.4.0a1721718347__py3-none-any.whl

pulumi_oci/__init__.py

@@ -115,8 +115,6 @@ if typing.TYPE_CHECKING:
     generativeai = __generativeai
     import pulumi_oci.genericartifactscontent as __genericartifactscontent
     genericartifactscontent = __genericartifactscontent
-    import pulumi_oci.globallydistributeddatabase as __globallydistributeddatabase
-    globallydistributeddatabase = __globallydistributeddatabase
     import pulumi_oci.goldengate as __goldengate
     goldengate = __goldengate
     import pulumi_oci.healthchecks as __healthchecks
@@ -295,7 +293,6 @@ else:
     fusionapps = _utilities.lazy_import('pulumi_oci.fusionapps')
     generativeai = _utilities.lazy_import('pulumi_oci.generativeai')
     genericartifactscontent = _utilities.lazy_import('pulumi_oci.genericartifactscontent')
-    globallydistributeddatabase = _utilities.lazy_import('pulumi_oci.globallydistributeddatabase')
     goldengate = _utilities.lazy_import('pulumi_oci.goldengate')
     healthchecks = _utilities.lazy_import('pulumi_oci.healthchecks')
     identity = _utilities.lazy_import('pulumi_oci.identity')
@@ -3578,22 +3575,6 @@ _utilities.register(
    "oci:GenericArtifactsContent/artifactByPath:ArtifactByPath": "ArtifactByPath"
   }
  },
- {
-  "pkg": "oci",
-  "mod": "GloballyDistributedDatabase/privateEndpoint",
-  "fqn": "pulumi_oci.globallydistributeddatabase",
-  "classes": {
-   "oci:GloballyDistributedDatabase/privateEndpoint:PrivateEndpoint": "PrivateEndpoint"
-  }
- },
- {
-  "pkg": "oci",
-  "mod": "GloballyDistributedDatabase/shardedDatabase",
-  "fqn": "pulumi_oci.globallydistributeddatabase",
-  "classes": {
-   "oci:GloballyDistributedDatabase/shardedDatabase:ShardedDatabase": "ShardedDatabase"
-  }
- },
  {
   "pkg": "oci",
   "mod": "GoldenGate/connection",

pulumi_oci/apmsynthetics/_inputs.py

@@ -15,12 +15,7 @@ __all__ = [
     'ConfigConfigurationClientCertificateDetailsArgs',
     'ConfigConfigurationClientCertificateDetailsClientCertificateArgs',
     'ConfigConfigurationClientCertificateDetailsPrivateKeyArgs',
-    'ConfigConfigurationDatabaseAuthenticationDetailsArgs',
-    'ConfigConfigurationDatabaseAuthenticationDetailsPasswordArgs',
-    'ConfigConfigurationDatabaseWalletDetailsArgs',
     'ConfigConfigurationDnsConfigurationArgs',
-    'ConfigConfigurationFtpBasicAuthenticationDetailsArgs',
-    'ConfigConfigurationFtpBasicAuthenticationDetailsPasswordArgs',
     'ConfigConfigurationNetworkConfigurationArgs',
     'ConfigConfigurationReqAuthenticationDetailsArgs',
     'ConfigConfigurationReqAuthenticationDetailsAuthHeaderArgs',
@@ -93,18 +88,7 @@ class ConfigConfigurationArgs:
     def __init__(__self__, *,
                  client_certificate_details: Optional[pulumi.Input['ConfigConfigurationClientCertificateDetailsArgs']] = None,
                  config_type: Optional[pulumi.Input[str]] = None,
-                 connection_string: Optional[pulumi.Input[str]] = None,
-                 database_authentication_details: Optional[pulumi.Input['ConfigConfigurationDatabaseAuthenticationDetailsArgs']] = None,
-                 database_connection_type: Optional[pulumi.Input[str]] = None,
-                 database_role: Optional[pulumi.Input[str]] = None,
-                 database_type: Optional[pulumi.Input[str]] = None,
-                 database_wallet_details: Optional[pulumi.Input['ConfigConfigurationDatabaseWalletDetailsArgs']] = None,
                  dns_configuration: Optional[pulumi.Input['ConfigConfigurationDnsConfigurationArgs']] = None,
-                 download_size_limit_in_bytes: Optional[pulumi.Input[int]] = None,
-                 ftp_basic_authentication_details: Optional[pulumi.Input['ConfigConfigurationFtpBasicAuthenticationDetailsArgs']] = None,
-                 ftp_protocol: Optional[pulumi.Input[str]] = None,
-                 ftp_request_type: Optional[pulumi.Input[str]] = None,
-                 is_active_mode: Optional[pulumi.Input[bool]] = None,
                  is_certificate_validation_enabled: Optional[pulumi.Input[bool]] = None,
                  is_default_snapshot_enabled: Optional[pulumi.Input[bool]] = None,
                  is_failure_retried: Optional[pulumi.Input[bool]] = None,
@@ -113,7 +97,6 @@ class ConfigConfigurationArgs:
                  name_server: Optional[pulumi.Input[str]] = None,
                  network_configuration: Optional[pulumi.Input['ConfigConfigurationNetworkConfigurationArgs']] = None,
                  protocol: Optional[pulumi.Input[str]] = None,
-                 query: Optional[pulumi.Input[str]] = None,
                  record_type: Optional[pulumi.Input[str]] = None,
                  req_authentication_details: Optional[pulumi.Input['ConfigConfigurationReqAuthenticationDetailsArgs']] = None,
                  req_authentication_scheme: Optional[pulumi.Input[str]] = None,
@@ -121,25 +104,13 @@ class ConfigConfigurationArgs:
                  request_method: Optional[pulumi.Input[str]] = None,
                  request_post_body: Optional[pulumi.Input[str]] = None,
                  request_query_params: Optional[pulumi.Input[Sequence[pulumi.Input['ConfigConfigurationRequestQueryParamArgs']]]] = None,
-                 upload_file_size_in_bytes: Optional[pulumi.Input[int]] = None,
                  verify_response_codes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  verify_response_content: Optional[pulumi.Input[str]] = None,
                  verify_texts: Optional[pulumi.Input[Sequence[pulumi.Input['ConfigConfigurationVerifyTextArgs']]]] = None):
         """
         :param pulumi.Input['ConfigConfigurationClientCertificateDetailsArgs'] client_certificate_details: (Updatable) Details for client certificate.
         :param pulumi.Input[str] config_type: (Updatable) Type of configuration.
-        :param pulumi.Input[str] connection_string: (Updatable) Database connection string.
-        :param pulumi.Input['ConfigConfigurationDatabaseAuthenticationDetailsArgs'] database_authentication_details: (Updatable) Details for basic authentication.
-        :param pulumi.Input[str] database_connection_type: (Updatable) Database connection type. Only CUSTOM_JDBC is supported for MYSQL database type.
-        :param pulumi.Input[str] database_role: (Updatable) Database role.
-        :param pulumi.Input[str] database_type: (Updatable) Database type.
-        :param pulumi.Input['ConfigConfigurationDatabaseWalletDetailsArgs'] database_wallet_details: (Updatable) Details for database wallet.
         :param pulumi.Input['ConfigConfigurationDnsConfigurationArgs'] dns_configuration: (Updatable) Information about the DNS settings.
-        :param pulumi.Input[int] download_size_limit_in_bytes: (Updatable) Download size limit in Bytes, at which to stop the transfer. Maximum download size limit is 5 MiB.
-        :param pulumi.Input['ConfigConfigurationFtpBasicAuthenticationDetailsArgs'] ftp_basic_authentication_details: (Updatable) Details for basic authentication.
-        :param pulumi.Input[str] ftp_protocol: (Updatable) FTP protocol type.
-        :param pulumi.Input[str] ftp_request_type: (Updatable) FTP monitor request type.
-        :param pulumi.Input[bool] is_active_mode: (Updatable) If enabled, Active mode will be used for the FTP connection.
         :param pulumi.Input[bool] is_certificate_validation_enabled: (Updatable) If certificate validation is enabled, then the call will fail in case of certification errors.
         :param pulumi.Input[bool] is_default_snapshot_enabled: (Updatable) If disabled, auto snapshots are not collected.
         :param pulumi.Input[bool] is_failure_retried: (Updatable) If isFailureRetried is enabled, then a failed call will be retried.
@@ -148,7 +119,6 @@ class ConfigConfigurationArgs:
         :param pulumi.Input[str] name_server: (Updatable) Name of the server that will be used to perform DNS lookup.
         :param pulumi.Input['ConfigConfigurationNetworkConfigurationArgs'] network_configuration: (Updatable) Details of the network configuration. For NETWORK monitor type, NetworkConfiguration is mandatory.
         :param pulumi.Input[str] protocol: (Updatable) Type of protocol.
-        :param pulumi.Input[str] query: (Updatable) SQL query to be executed.
         :param pulumi.Input[str] record_type: (Updatable) DNS record type.
         :param pulumi.Input['ConfigConfigurationReqAuthenticationDetailsArgs'] req_authentication_details: (Updatable) Details for request HTTP authentication.
         :param pulumi.Input[str] req_authentication_scheme: (Updatable) Request HTTP authentication scheme.
@@ -156,7 +126,6 @@ class ConfigConfigurationArgs:
         :param pulumi.Input[str] request_method: (Updatable) Request HTTP method.
         :param pulumi.Input[str] request_post_body: (Updatable) Request post body content.
         :param pulumi.Input[Sequence[pulumi.Input['ConfigConfigurationRequestQueryParamArgs']]] request_query_params: (Updatable) List of request query params. Example: `[{"paramName": "sortOrder", "paramValue": "asc"}]`
-        :param pulumi.Input[int] upload_file_size_in_bytes: (Updatable) File upload size in Bytes, at which to stop the transfer. Maximum upload size is 5 MiB.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] verify_response_codes: (Updatable) Expected HTTP response codes. For status code range, set values such as 2xx, 3xx.
         :param pulumi.Input[str] verify_response_content: (Updatable) Verify response content against regular expression based string. If response content does not match the verifyResponseContent value, then it will be considered a failure.
         :param pulumi.Input[Sequence[pulumi.Input['ConfigConfigurationVerifyTextArgs']]] verify_texts: (Updatable) Verifies all the search strings present in the response. If any search string is not present in the response, then it will be considered as a failure.
@@ -165,30 +134,8 @@ class ConfigConfigurationArgs:
             pulumi.set(__self__, "client_certificate_details", client_certificate_details)
         if config_type is not None:
             pulumi.set(__self__, "config_type", config_type)
-        if connection_string is not None:
-            pulumi.set(__self__, "connection_string", connection_string)
-        if database_authentication_details is not None:
-            pulumi.set(__self__, "database_authentication_details", database_authentication_details)
-        if database_connection_type is not None:
-            pulumi.set(__self__, "database_connection_type", database_connection_type)
-        if database_role is not None:
-            pulumi.set(__self__, "database_role", database_role)
-        if database_type is not None:
-            pulumi.set(__self__, "database_type", database_type)
-        if database_wallet_details is not None:
-            pulumi.set(__self__, "database_wallet_details", database_wallet_details)
         if dns_configuration is not None:
             pulumi.set(__self__, "dns_configuration", dns_configuration)
-        if download_size_limit_in_bytes is not None:
-            pulumi.set(__self__, "download_size_limit_in_bytes", download_size_limit_in_bytes)
-        if ftp_basic_authentication_details is not None:
-            pulumi.set(__self__, "ftp_basic_authentication_details", ftp_basic_authentication_details)
-        if ftp_protocol is not None:
-            pulumi.set(__self__, "ftp_protocol", ftp_protocol)
-        if ftp_request_type is not None:
-            pulumi.set(__self__, "ftp_request_type", ftp_request_type)
-        if is_active_mode is not None:
-            pulumi.set(__self__, "is_active_mode", is_active_mode)
         if is_certificate_validation_enabled is not None:
             pulumi.set(__self__, "is_certificate_validation_enabled", is_certificate_validation_enabled)
         if is_default_snapshot_enabled is not None:
@@ -205,8 +152,6 @@ class ConfigConfigurationArgs:
             pulumi.set(__self__, "network_configuration", network_configuration)
         if protocol is not None:
             pulumi.set(__self__, "protocol", protocol)
-        if query is not None:
-            pulumi.set(__self__, "query", query)
         if record_type is not None:
             pulumi.set(__self__, "record_type", record_type)
         if req_authentication_details is not None:
@@ -221,8 +166,6 @@ class ConfigConfigurationArgs:
             pulumi.set(__self__, "request_post_body", request_post_body)
         if request_query_params is not None:
             pulumi.set(__self__, "request_query_params", request_query_params)
-        if upload_file_size_in_bytes is not None:
-            pulumi.set(__self__, "upload_file_size_in_bytes", upload_file_size_in_bytes)
         if verify_response_codes is not None:
             pulumi.set(__self__, "verify_response_codes", verify_response_codes)
         if verify_response_content is not None:
@@ -254,78 +197,6 @@ class ConfigConfigurationArgs:
     def config_type(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "config_type", value)
 
-    @property
-    @pulumi.getter(name="connectionString")
-    def connection_string(self) -> Optional[pulumi.Input[str]]:
-        """
-        (Updatable) Database connection string.
-        """
-        return pulumi.get(self, "connection_string")
-
-    @connection_string.setter
-    def connection_string(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "connection_string", value)
-
-    @property
-    @pulumi.getter(name="databaseAuthenticationDetails")
-    def database_authentication_details(self) -> Optional[pulumi.Input['ConfigConfigurationDatabaseAuthenticationDetailsArgs']]:
-        """
-        (Updatable) Details for basic authentication.
-        """
-        return pulumi.get(self, "database_authentication_details")
-
-    @database_authentication_details.setter
-    def database_authentication_details(self, value: Optional[pulumi.Input['ConfigConfigurationDatabaseAuthenticationDetailsArgs']]):
-        pulumi.set(self, "database_authentication_details", value)
-
-    @property
-    @pulumi.getter(name="databaseConnectionType")
-    def database_connection_type(self) -> Optional[pulumi.Input[str]]:
-        """
-        (Updatable) Database connection type. Only CUSTOM_JDBC is supported for MYSQL database type.
-        """
-        return pulumi.get(self, "database_connection_type")
-
-    @database_connection_type.setter
-    def database_connection_type(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "database_connection_type", value)
-
-    @property
-    @pulumi.getter(name="databaseRole")
-    def database_role(self) -> Optional[pulumi.Input[str]]:
-        """
-        (Updatable) Database role.
-        """
-        return pulumi.get(self, "database_role")
-
-    @database_role.setter
-    def database_role(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "database_role", value)
-
-    @property
-    @pulumi.getter(name="databaseType")
-    def database_type(self) -> Optional[pulumi.Input[str]]:
-        """
-        (Updatable) Database type.
-        """
-        return pulumi.get(self, "database_type")
-
-    @database_type.setter
-    def database_type(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "database_type", value)
-
-    @property
-    @pulumi.getter(name="databaseWalletDetails")
-    def database_wallet_details(self) -> Optional[pulumi.Input['ConfigConfigurationDatabaseWalletDetailsArgs']]:
-        """
-        (Updatable) Details for database wallet.
-        """
-        return pulumi.get(self, "database_wallet_details")
-
-    @database_wallet_details.setter
-    def database_wallet_details(self, value: Optional[pulumi.Input['ConfigConfigurationDatabaseWalletDetailsArgs']]):
-        pulumi.set(self, "database_wallet_details", value)
-
     @property
     @pulumi.getter(name="dnsConfiguration")
     def dns_configuration(self) -> Optional[pulumi.Input['ConfigConfigurationDnsConfigurationArgs']]:
@@ -338,66 +209,6 @@ class ConfigConfigurationArgs:
     def dns_configuration(self, value: Optional[pulumi.Input['ConfigConfigurationDnsConfigurationArgs']]):
         pulumi.set(self, "dns_configuration", value)
 
-    @property
-    @pulumi.getter(name="downloadSizeLimitInBytes")
-    def download_size_limit_in_bytes(self) -> Optional[pulumi.Input[int]]:
-        """
-        (Updatable) Download size limit in Bytes, at which to stop the transfer. Maximum download size limit is 5 MiB.
-        """
-        return pulumi.get(self, "download_size_limit_in_bytes")
-
-    @download_size_limit_in_bytes.setter
-    def download_size_limit_in_bytes(self, value: Optional[pulumi.Input[int]]):
-        pulumi.set(self, "download_size_limit_in_bytes", value)
-
-    @property
-    @pulumi.getter(name="ftpBasicAuthenticationDetails")
-    def ftp_basic_authentication_details(self) -> Optional[pulumi.Input['ConfigConfigurationFtpBasicAuthenticationDetailsArgs']]:
-        """
-        (Updatable) Details for basic authentication.
-        """
-        return pulumi.get(self, "ftp_basic_authentication_details")
-
-    @ftp_basic_authentication_details.setter
-    def ftp_basic_authentication_details(self, value: Optional[pulumi.Input['ConfigConfigurationFtpBasicAuthenticationDetailsArgs']]):
-        pulumi.set(self, "ftp_basic_authentication_details", value)
-
-    @property
-    @pulumi.getter(name="ftpProtocol")
-    def ftp_protocol(self) -> Optional[pulumi.Input[str]]:
-        """
-        (Updatable) FTP protocol type.
-        """
-        return pulumi.get(self, "ftp_protocol")
-
-    @ftp_protocol.setter
-    def ftp_protocol(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "ftp_protocol", value)
-
-    @property
-    @pulumi.getter(name="ftpRequestType")
-    def ftp_request_type(self) -> Optional[pulumi.Input[str]]:
-        """
-        (Updatable) FTP monitor request type.
-        """
-        return pulumi.get(self, "ftp_request_type")
-
-    @ftp_request_type.setter
-    def ftp_request_type(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "ftp_request_type", value)
-
-    @property
-    @pulumi.getter(name="isActiveMode")
-    def is_active_mode(self) -> Optional[pulumi.Input[bool]]:
-        """
-        (Updatable) If enabled, Active mode will be used for the FTP connection.
-        """
-        return pulumi.get(self, "is_active_mode")
-
-    @is_active_mode.setter
-    def is_active_mode(self, value: Optional[pulumi.Input[bool]]):
-        pulumi.set(self, "is_active_mode", value)
-
     @property
     @pulumi.getter(name="isCertificateValidationEnabled")
     def is_certificate_validation_enabled(self) -> Optional[pulumi.Input[bool]]:
@@ -494,18 +305,6 @@ class ConfigConfigurationArgs:
     def protocol(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "protocol", value)
 
-    @property
-    @pulumi.getter
-    def query(self) -> Optional[pulumi.Input[str]]:
-        """
-        (Updatable) SQL query to be executed.
-        """
-        return pulumi.get(self, "query")
-
-    @query.setter
-    def query(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "query", value)
-
     @property
     @pulumi.getter(name="recordType")
     def record_type(self) -> Optional[pulumi.Input[str]]:
@@ -590,18 +389,6 @@ class ConfigConfigurationArgs:
     def request_query_params(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ConfigConfigurationRequestQueryParamArgs']]]]):
         pulumi.set(self, "request_query_params", value)
 
-    @property
-    @pulumi.getter(name="uploadFileSizeInBytes")
-    def upload_file_size_in_bytes(self) -> Optional[pulumi.Input[int]]:
-        """
-        (Updatable) File upload size in Bytes, at which to stop the transfer. Maximum upload size is 5 MiB.
-        """
-        return pulumi.get(self, "upload_file_size_in_bytes")
-
-    @upload_file_size_in_bytes.setter
-    def upload_file_size_in_bytes(self, value: Optional[pulumi.Input[int]]):
-        pulumi.set(self, "upload_file_size_in_bytes", value)
-
     @property
     @pulumi.getter(name="verifyResponseCodes")
     def verify_response_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
@@ -756,139 +543,6 @@ class ConfigConfigurationClientCertificateDetailsPrivateKeyArgs:
         pulumi.set(self, "file_name", value)
 
 
-@pulumi.input_type
-class ConfigConfigurationDatabaseAuthenticationDetailsArgs:
-    def __init__(__self__, *,
-                 password: Optional[pulumi.Input['ConfigConfigurationDatabaseAuthenticationDetailsPasswordArgs']] = None,
-                 username: Optional[pulumi.Input[str]] = None):
-        """
-        :param pulumi.Input['ConfigConfigurationDatabaseAuthenticationDetailsPasswordArgs'] password: (Updatable) Password.
-        :param pulumi.Input[str] username: (Updatable) Username for authentication.
-        """
-        if password is not None:
-            pulumi.set(__self__, "password", password)
-        if username is not None:
-            pulumi.set(__self__, "username", username)
-
-    @property
-    @pulumi.getter
-    def password(self) -> Optional[pulumi.Input['ConfigConfigurationDatabaseAuthenticationDetailsPasswordArgs']]:
-        """
-        (Updatable) Password.
-        """
-        return pulumi.get(self, "password")
-
-    @password.setter
-    def password(self, value: Optional[pulumi.Input['ConfigConfigurationDatabaseAuthenticationDetailsPasswordArgs']]):
-        pulumi.set(self, "password", value)
-
-    @property
-    @pulumi.getter
-    def username(self) -> Optional[pulumi.Input[str]]:
-        """
-        (Updatable) Username for authentication.
-        """
-        return pulumi.get(self, "username")
-
-    @username.setter
-    def username(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "username", value)
-
-
-@pulumi.input_type
-class ConfigConfigurationDatabaseAuthenticationDetailsPasswordArgs:
-    def __init__(__self__, *,
-                 password: Optional[pulumi.Input[str]] = None,
-                 password_type: Optional[pulumi.Input[str]] = None,
-                 vault_secret_id: Optional[pulumi.Input[str]] = None):
-        """
-        :param pulumi.Input[str] password: (Updatable) Password.
-        :param pulumi.Input[str] password_type: (Updatable) Type of method to pass password.
-        :param pulumi.Input[str] vault_secret_id: (Updatable) Vault secret OCID.
-        """
-        if password is not None:
-            pulumi.set(__self__, "password", password)
-        if password_type is not None:
-            pulumi.set(__self__, "password_type", password_type)
-        if vault_secret_id is not None:
-            pulumi.set(__self__, "vault_secret_id", vault_secret_id)
-
-    @property
-    @pulumi.getter
-    def password(self) -> Optional[pulumi.Input[str]]:
-        """
-        (Updatable) Password.
-        """
-        return pulumi.get(self, "password")
-
-    @password.setter
-    def password(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "password", value)
-
-    @property
-    @pulumi.getter(name="passwordType")
-    def password_type(self) -> Optional[pulumi.Input[str]]:
-        """
-        (Updatable) Type of method to pass password.
-        """
-        return pulumi.get(self, "password_type")
-
-    @password_type.setter
-    def password_type(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "password_type", value)
-
-    @property
-    @pulumi.getter(name="vaultSecretId")
-    def vault_secret_id(self) -> Optional[pulumi.Input[str]]:
-        """
-        (Updatable) Vault secret OCID.
-        """
-        return pulumi.get(self, "vault_secret_id")
-
-    @vault_secret_id.setter
-    def vault_secret_id(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "vault_secret_id", value)
-
-
-@pulumi.input_type
-class ConfigConfigurationDatabaseWalletDetailsArgs:
-    def __init__(__self__, *,
-                 database_wallet: Optional[pulumi.Input[str]] = None,
-                 service_name: Optional[pulumi.Input[str]] = None):
-        """
-        :param pulumi.Input[str] database_wallet: (Updatable) The database wallet configuration zip file.
-        :param pulumi.Input[str] service_name: (Updatable) Service name of the database.
-        """
-        if database_wallet is not None:
-            pulumi.set(__self__, "database_wallet", database_wallet)
-        if service_name is not None:
-            pulumi.set(__self__, "service_name", service_name)
-
-    @property
-    @pulumi.getter(name="databaseWallet")
-    def database_wallet(self) -> Optional[pulumi.Input[str]]:
-        """
-        (Updatable) The database wallet configuration zip file.
-        """
-        return pulumi.get(self, "database_wallet")
-
-    @database_wallet.setter
-    def database_wallet(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "database_wallet", value)
-
-    @property
-    @pulumi.getter(name="serviceName")
-    def service_name(self) -> Optional[pulumi.Input[str]]:
-        """
-        (Updatable) Service name of the database.
-        """
-        return pulumi.get(self, "service_name")
-
-    @service_name.setter
-    def service_name(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "service_name", value)
-
-
 @pulumi.input_type
 class ConfigConfigurationDnsConfigurationArgs:
     def __init__(__self__, *,
@@ -928,100 +582,6 @@ class ConfigConfigurationDnsConfigurationArgs:
         pulumi.set(self, "override_dns_ip", value)
 
 
-@pulumi.input_type
-class ConfigConfigurationFtpBasicAuthenticationDetailsArgs:
-    def __init__(__self__, *,
-                 password: Optional[pulumi.Input['ConfigConfigurationFtpBasicAuthenticationDetailsPasswordArgs']] = None,
-                 username: Optional[pulumi.Input[str]] = None):
-        """
-        :param pulumi.Input['ConfigConfigurationFtpBasicAuthenticationDetailsPasswordArgs'] password: (Updatable) Password.
-        :param pulumi.Input[str] username: (Updatable) Username for authentication.
-        """
-        if password is not None:
-            pulumi.set(__self__, "password", password)
-        if username is not None:
-            pulumi.set(__self__, "username", username)
-
-    @property
-    @pulumi.getter
-    def password(self) -> Optional[pulumi.Input['ConfigConfigurationFtpBasicAuthenticationDetailsPasswordArgs']]:
-        """
-        (Updatable) Password.
-        """
-        return pulumi.get(self, "password")
-
-    @password.setter
-    def password(self, value: Optional[pulumi.Input['ConfigConfigurationFtpBasicAuthenticationDetailsPasswordArgs']]):
-        pulumi.set(self, "password", value)
-
-    @property
-    @pulumi.getter
-    def username(self) -> Optional[pulumi.Input[str]]:
-        """
-        (Updatable) Username for authentication.
-        """
-        return pulumi.get(self, "username")
-
-    @username.setter
-    def username(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "username", value)
-
-
-@pulumi.input_type
-class ConfigConfigurationFtpBasicAuthenticationDetailsPasswordArgs:
-    def __init__(__self__, *,
-                 password: Optional[pulumi.Input[str]] = None,
-                 password_type: Optional[pulumi.Input[str]] = None,
-                 vault_secret_id: Optional[pulumi.Input[str]] = None):
-        """
-        :param pulumi.Input[str] password: (Updatable) Password.
-        :param pulumi.Input[str] password_type: (Updatable) Type of method to pass password.
-        :param pulumi.Input[str] vault_secret_id: (Updatable) Vault secret OCID.
-        """
-        if password is not None:
-            pulumi.set(__self__, "password", password)
-        if password_type is not None:
-            pulumi.set(__self__, "password_type", password_type)
-        if vault_secret_id is not None:
-            pulumi.set(__self__, "vault_secret_id", vault_secret_id)
-
-    @property
-    @pulumi.getter
-    def password(self) -> Optional[pulumi.Input[str]]:
-        """
-        (Updatable) Password.
-        """
-        return pulumi.get(self, "password")
-
-    @password.setter
-    def password(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "password", value)
-
-    @property
-    @pulumi.getter(name="passwordType")
-    def password_type(self) -> Optional[pulumi.Input[str]]:
-        """
-        (Updatable) Type of method to pass password.
-        """
-        return pulumi.get(self, "password_type")
-
-    @password_type.setter
-    def password_type(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "password_type", value)
-
-    @property
-    @pulumi.getter(name="vaultSecretId")
-    def vault_secret_id(self) -> Optional[pulumi.Input[str]]:
-        """
-        (Updatable) Vault secret OCID.
-        """
-        return pulumi.get(self, "vault_secret_id")
-
-    @vault_secret_id.setter
-    def vault_secret_id(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "vault_secret_id", value)
-
-
 @pulumi.input_type
 class ConfigConfigurationNetworkConfigurationArgs:
     def __init__(__self__, *,
@@ -1551,18 +1111,14 @@ class ConfigScriptParameterMonitorScriptParameterArgs:
 class ConfigVantagePointArgs:
     def __init__(__self__, *,
                  name: pulumi.Input[str],
-                 display_name: Optional[pulumi.Input[str]] = None,
-                 worker_lists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+                 display_name: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[str] name: Name of the vantage point.
         :param pulumi.Input[str] display_name: Unique name that can be edited. The name should not contain any confidential information.
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] worker_lists: List of workers running the assigned monitor.
         """
         pulumi.set(__self__, "name", name)
         if display_name is not None:
             pulumi.set(__self__, "display_name", display_name)
-        if worker_lists is not None:
-            pulumi.set(__self__, "worker_lists", worker_lists)
 
     @property
     @pulumi.getter
@@ -1588,18 +1144,6 @@ class ConfigVantagePointArgs:
     def display_name(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "display_name", value)
 
-    @property
-    @pulumi.getter(name="workerLists")
-    def worker_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
-        """
-        List of workers running the assigned monitor.
-        """
-        return pulumi.get(self, "worker_lists")
-
-    @worker_lists.setter
-    def worker_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
-        pulumi.set(self, "worker_lists", value)
-
 
 @pulumi.input_type
 class DedicatedVantagePointDvpStackDetailsArgs: