pulumi-gcp 8.21.0a1741156431__py3-none-any.whl → 8.22.0__py3-none-any.whl

pulumi_gcp/dataproc/outputs.py

@@ -3791,7 +3791,7 @@ class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicy(dict)
         """
         :param Sequence['ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionListArgs'] instance_selection_lists: List of instance selection options that the group will use when creating new VMs.
         :param Sequence['ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionResultArgs'] instance_selection_results: A list of instance selection results in the group.
-        :param 'ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvisioningModelMixArgs' provisioning_model_mix: Defines how Dataproc should create VMs with a mixture of provisioning models.
+        :param 'ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvisioningModelMixArgs' provisioning_model_mix: Defines how the Group selects the provisioning model to ensure required reliability.
         """
         if instance_selection_lists is not None:
             pulumi.set(__self__, "instance_selection_lists", instance_selection_lists)
@@ -3820,7 +3820,7 @@ class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicy(dict)
     @pulumi.getter(name="provisioningModelMix")
     def provisioning_model_mix(self) -> Optional['outputs.ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvisioningModelMix']:
         """
-        Defines how Dataproc should create VMs with a mixture of provisioning models.
+        Defines how the Group selects the provisioning model to ensure required reliability.
         """
         return pulumi.get(self, "provisioning_model_mix")
 
@@ -3850,8 +3850,6 @@ class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstan
         """
         :param Sequence[str] machine_types: Full machine-type names, e.g. `"n1-standard-16"`.
         :param int rank: Preference of this instance selection. A lower number means higher preference. Dataproc will first try to create a VM based on the machine-type with priority rank and fallback to next rank based on availability. Machine types and instance selections with the same priority have the same preference.
-               
-               - - -
         """
         if machine_types is not None:
             pulumi.set(__self__, "machine_types", machine_types)
@@ -3871,8 +3869,6 @@ class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstan
     def rank(self) -> Optional[int]:
         """
         Preference of this instance selection. A lower number means higher preference. Dataproc will first try to create a VM based on the machine-type with priority rank and fallback to next rank based on availability. Machine types and instance selections with the same priority have the same preference.
-
-        - - -
         """
         return pulumi.get(self, "rank")
 
@@ -3952,8 +3948,9 @@ class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvis
                  standard_capacity_base: Optional[int] = None,
                  standard_capacity_percent_above_base: Optional[int] = None):
         """
-        :param int standard_capacity_base: The base capacity that will always use Standard VMs to avoid risk of more preemption than the minimum capacity you need.
-        :param int standard_capacity_percent_above_base: The percentage of target capacity that should use Standard VM. The remaining percentage will use Spot VMs.
+        :param int standard_capacity_base: The base capacity that will always use Standard VMs to avoid risk of more preemption than the minimum capacity you need. Dataproc will create only standard VMs until it reaches standardCapacityBase, then it will start using standardCapacityPercentAboveBase to mix Spot with Standard VMs. eg. If 15 instances are requested and standardCapacityBase is 5, Dataproc will create 5 standard VMs and then start mixing spot and standard VMs for remaining 10 instances.
+        :param int standard_capacity_percent_above_base: The percentage of target capacity that should use Standard VM. The remaining percentage will use Spot VMs. The percentage applies only to the capacity above standardCapacityBase. eg. If 15 instances are requested and standardCapacityBase is 5 and standardCapacityPercentAboveBase is 30, Dataproc will create 5 standard VMs and then start mixing spot and standard VMs for remaining 10 instances. The mix will be 30% standard and 70% spot.
+               - - -
         """
         if standard_capacity_base is not None:
             pulumi.set(__self__, "standard_capacity_base", standard_capacity_base)
@@ -3964,7 +3961,7 @@ class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvis
     @pulumi.getter(name="standardCapacityBase")
     def standard_capacity_base(self) -> Optional[int]:
         """
-        The base capacity that will always use Standard VMs to avoid risk of more preemption than the minimum capacity you need.
+        The base capacity that will always use Standard VMs to avoid risk of more preemption than the minimum capacity you need. Dataproc will create only standard VMs until it reaches standardCapacityBase, then it will start using standardCapacityPercentAboveBase to mix Spot with Standard VMs. eg. If 15 instances are requested and standardCapacityBase is 5, Dataproc will create 5 standard VMs and then start mixing spot and standard VMs for remaining 10 instances.
         """
         return pulumi.get(self, "standard_capacity_base")
 
@@ -3972,7 +3969,8 @@ class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvis
     @pulumi.getter(name="standardCapacityPercentAboveBase")
     def standard_capacity_percent_above_base(self) -> Optional[int]:
         """
-        The percentage of target capacity that should use Standard VM. The remaining percentage will use Spot VMs.
+        The percentage of target capacity that should use Standard VM. The remaining percentage will use Spot VMs. The percentage applies only to the capacity above standardCapacityBase. eg. If 15 instances are requested and standardCapacityBase is 5 and standardCapacityPercentAboveBase is 30, Dataproc will create 5 standard VMs and then start mixing spot and standard VMs for remaining 10 instances. The mix will be 30% standard and 70% spot.
+        - - -
         """
         return pulumi.get(self, "standard_capacity_percent_above_base")
 

pulumi_gcp/datastream/_inputs.py

@@ -31,6 +31,12 @@ __all__ = [
     'ConnectionProfilePostgresqlProfileArgsDict',
     'ConnectionProfilePrivateConnectivityArgs',
     'ConnectionProfilePrivateConnectivityArgsDict',
+    'ConnectionProfileSalesforceProfileArgs',
+    'ConnectionProfileSalesforceProfileArgsDict',
+    'ConnectionProfileSalesforceProfileOauth2ClientCredentialsArgs',
+    'ConnectionProfileSalesforceProfileOauth2ClientCredentialsArgsDict',
+    'ConnectionProfileSalesforceProfileUserCredentialsArgs',
+    'ConnectionProfileSalesforceProfileUserCredentialsArgsDict',
     'ConnectionProfileSqlServerProfileArgs',
     'ConnectionProfileSqlServerProfileArgsDict',
     'PrivateConnectionErrorArgs',
@@ -918,6 +924,273 @@ class ConnectionProfilePrivateConnectivityArgs:
         pulumi.set(self, "private_connection", value)
 
 
+if not MYPY:
+    class ConnectionProfileSalesforceProfileArgsDict(TypedDict):
+        domain: pulumi.Input[str]
+        """
+        Domain for the Salesforce Org.
+        """
+        oauth2_client_credentials: NotRequired[pulumi.Input['ConnectionProfileSalesforceProfileOauth2ClientCredentialsArgsDict']]
+        """
+        OAuth credentials to use for Salesforce authentication.
+        Structure is documented below.
+        """
+        user_credentials: NotRequired[pulumi.Input['ConnectionProfileSalesforceProfileUserCredentialsArgsDict']]
+        """
+        User credentials to use for Salesforce authentication.
+        Structure is documented below.
+        """
+elif False:
+    ConnectionProfileSalesforceProfileArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ConnectionProfileSalesforceProfileArgs:
+    def __init__(__self__, *,
+                 domain: pulumi.Input[str],
+                 oauth2_client_credentials: Optional[pulumi.Input['ConnectionProfileSalesforceProfileOauth2ClientCredentialsArgs']] = None,
+                 user_credentials: Optional[pulumi.Input['ConnectionProfileSalesforceProfileUserCredentialsArgs']] = None):
+        """
+        :param pulumi.Input[str] domain: Domain for the Salesforce Org.
+        :param pulumi.Input['ConnectionProfileSalesforceProfileOauth2ClientCredentialsArgs'] oauth2_client_credentials: OAuth credentials to use for Salesforce authentication.
+               Structure is documented below.
+        :param pulumi.Input['ConnectionProfileSalesforceProfileUserCredentialsArgs'] user_credentials: User credentials to use for Salesforce authentication.
+               Structure is documented below.
+        """
+        pulumi.set(__self__, "domain", domain)
+        if oauth2_client_credentials is not None:
+            pulumi.set(__self__, "oauth2_client_credentials", oauth2_client_credentials)
+        if user_credentials is not None:
+            pulumi.set(__self__, "user_credentials", user_credentials)
+
+    @property
+    @pulumi.getter
+    def domain(self) -> pulumi.Input[str]:
+        """
+        Domain for the Salesforce Org.
+        """
+        return pulumi.get(self, "domain")
+
+    @domain.setter
+    def domain(self, value: pulumi.Input[str]):
+        pulumi.set(self, "domain", value)
+
+    @property
+    @pulumi.getter(name="oauth2ClientCredentials")
+    def oauth2_client_credentials(self) -> Optional[pulumi.Input['ConnectionProfileSalesforceProfileOauth2ClientCredentialsArgs']]:
+        """
+        OAuth credentials to use for Salesforce authentication.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "oauth2_client_credentials")
+
+    @oauth2_client_credentials.setter
+    def oauth2_client_credentials(self, value: Optional[pulumi.Input['ConnectionProfileSalesforceProfileOauth2ClientCredentialsArgs']]):
+        pulumi.set(self, "oauth2_client_credentials", value)
+
+    @property
+    @pulumi.getter(name="userCredentials")
+    def user_credentials(self) -> Optional[pulumi.Input['ConnectionProfileSalesforceProfileUserCredentialsArgs']]:
+        """
+        User credentials to use for Salesforce authentication.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "user_credentials")
+
+    @user_credentials.setter
+    def user_credentials(self, value: Optional[pulumi.Input['ConnectionProfileSalesforceProfileUserCredentialsArgs']]):
+        pulumi.set(self, "user_credentials", value)
+
+
+if not MYPY:
+    class ConnectionProfileSalesforceProfileOauth2ClientCredentialsArgsDict(TypedDict):
+        client_id: NotRequired[pulumi.Input[str]]
+        """
+        Client ID to use for authentication.
+        """
+        client_secret: NotRequired[pulumi.Input[str]]
+        """
+        Client secret to use for authentication.
+        """
+        secret_manager_stored_client_secret: NotRequired[pulumi.Input[str]]
+        """
+        A reference to a Secret Manager resource name storing the client secret.
+        """
+elif False:
+    ConnectionProfileSalesforceProfileOauth2ClientCredentialsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ConnectionProfileSalesforceProfileOauth2ClientCredentialsArgs:
+    def __init__(__self__, *,
+                 client_id: Optional[pulumi.Input[str]] = None,
+                 client_secret: Optional[pulumi.Input[str]] = None,
+                 secret_manager_stored_client_secret: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] client_id: Client ID to use for authentication.
+        :param pulumi.Input[str] client_secret: Client secret to use for authentication.
+        :param pulumi.Input[str] secret_manager_stored_client_secret: A reference to a Secret Manager resource name storing the client secret.
+        """
+        if client_id is not None:
+            pulumi.set(__self__, "client_id", client_id)
+        if client_secret is not None:
+            pulumi.set(__self__, "client_secret", client_secret)
+        if secret_manager_stored_client_secret is not None:
+            pulumi.set(__self__, "secret_manager_stored_client_secret", secret_manager_stored_client_secret)
+
+    @property
+    @pulumi.getter(name="clientId")
+    def client_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        Client ID to use for authentication.
+        """
+        return pulumi.get(self, "client_id")
+
+    @client_id.setter
+    def client_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "client_id", value)
+
+    @property
+    @pulumi.getter(name="clientSecret")
+    def client_secret(self) -> Optional[pulumi.Input[str]]:
+        """
+        Client secret to use for authentication.
+        """
+        return pulumi.get(self, "client_secret")
+
+    @client_secret.setter
+    def client_secret(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "client_secret", value)
+
+    @property
+    @pulumi.getter(name="secretManagerStoredClientSecret")
+    def secret_manager_stored_client_secret(self) -> Optional[pulumi.Input[str]]:
+        """
+        A reference to a Secret Manager resource name storing the client secret.
+        """
+        return pulumi.get(self, "secret_manager_stored_client_secret")
+
+    @secret_manager_stored_client_secret.setter
+    def secret_manager_stored_client_secret(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "secret_manager_stored_client_secret", value)
+
+
+if not MYPY:
+    class ConnectionProfileSalesforceProfileUserCredentialsArgsDict(TypedDict):
+        password: NotRequired[pulumi.Input[str]]
+        """
+        Password of the user.
+        """
+        secret_manager_stored_password: NotRequired[pulumi.Input[str]]
+        """
+        A reference to a Secret Manager resource name storing the user's password.
+        """
+        secret_manager_stored_security_token: NotRequired[pulumi.Input[str]]
+        """
+        A reference to a Secret Manager resource name storing the user's security token.
+
+        <a name="nested_salesforce_profile_oauth2_client_credentials"></a>The `oauth2_client_credentials` block supports:
+        """
+        security_token: NotRequired[pulumi.Input[str]]
+        """
+        Security token of the user.
+        """
+        username: NotRequired[pulumi.Input[str]]
+        """
+        Username to use for authentication.
+        """
+elif False:
+    ConnectionProfileSalesforceProfileUserCredentialsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ConnectionProfileSalesforceProfileUserCredentialsArgs:
+    def __init__(__self__, *,
+                 password: Optional[pulumi.Input[str]] = None,
+                 secret_manager_stored_password: Optional[pulumi.Input[str]] = None,
+                 secret_manager_stored_security_token: Optional[pulumi.Input[str]] = None,
+                 security_token: Optional[pulumi.Input[str]] = None,
+                 username: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] password: Password of the user.
+        :param pulumi.Input[str] secret_manager_stored_password: A reference to a Secret Manager resource name storing the user's password.
+        :param pulumi.Input[str] secret_manager_stored_security_token: A reference to a Secret Manager resource name storing the user's security token.
+               
+               <a name="nested_salesforce_profile_oauth2_client_credentials"></a>The `oauth2_client_credentials` block supports:
+        :param pulumi.Input[str] security_token: Security token of the user.
+        :param pulumi.Input[str] username: Username to use for authentication.
+        """
+        if password is not None:
+            pulumi.set(__self__, "password", password)
+        if secret_manager_stored_password is not None:
+            pulumi.set(__self__, "secret_manager_stored_password", secret_manager_stored_password)
+        if secret_manager_stored_security_token is not None:
+            pulumi.set(__self__, "secret_manager_stored_security_token", secret_manager_stored_security_token)
+        if security_token is not None:
+            pulumi.set(__self__, "security_token", security_token)
+        if username is not None:
+            pulumi.set(__self__, "username", username)
+
+    @property
+    @pulumi.getter
+    def password(self) -> Optional[pulumi.Input[str]]:
+        """
+        Password of the user.
+        """
+        return pulumi.get(self, "password")
+
+    @password.setter
+    def password(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "password", value)
+
+    @property
+    @pulumi.getter(name="secretManagerStoredPassword")
+    def secret_manager_stored_password(self) -> Optional[pulumi.Input[str]]:
+        """
+        A reference to a Secret Manager resource name storing the user's password.
+        """
+        return pulumi.get(self, "secret_manager_stored_password")
+
+    @secret_manager_stored_password.setter
+    def secret_manager_stored_password(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "secret_manager_stored_password", value)
+
+    @property
+    @pulumi.getter(name="secretManagerStoredSecurityToken")
+    def secret_manager_stored_security_token(self) -> Optional[pulumi.Input[str]]:
+        """
+        A reference to a Secret Manager resource name storing the user's security token.
+
+        <a name="nested_salesforce_profile_oauth2_client_credentials"></a>The `oauth2_client_credentials` block supports:
+        """
+        return pulumi.get(self, "secret_manager_stored_security_token")
+
+    @secret_manager_stored_security_token.setter
+    def secret_manager_stored_security_token(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "secret_manager_stored_security_token", value)
+
+    @property
+    @pulumi.getter(name="securityToken")
+    def security_token(self) -> Optional[pulumi.Input[str]]:
+        """
+        Security token of the user.
+        """
+        return pulumi.get(self, "security_token")
+
+    @security_token.setter
+    def security_token(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "security_token", value)
+
+    @property
+    @pulumi.getter
+    def username(self) -> Optional[pulumi.Input[str]]:
+        """
+        Username to use for authentication.
+        """
+        return pulumi.get(self, "username")
+
+    @username.setter
+    def username(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "username", value)
+
+
 if not MYPY:
     class ConnectionProfileSqlServerProfileArgsDict(TypedDict):
         database: pulumi.Input[str]

pulumi_gcp/datastream/connection_profile.py

@@ -34,6 +34,7 @@ class ConnectionProfileArgs:
                  postgresql_profile: Optional[pulumi.Input['ConnectionProfilePostgresqlProfileArgs']] = None,
                  private_connectivity: Optional[pulumi.Input['ConnectionProfilePrivateConnectivityArgs']] = None,
                  project: Optional[pulumi.Input[str]] = None,
+                 salesforce_profile: Optional[pulumi.Input['ConnectionProfileSalesforceProfileArgs']] = None,
                  sql_server_profile: Optional[pulumi.Input['ConnectionProfileSqlServerProfileArgs']] = None):
         """
         The set of arguments for constructing a ConnectionProfile resource.
@@ -62,6 +63,8 @@ class ConnectionProfileArgs:
                Structure is documented below.
         :param pulumi.Input[str] project: The ID of the project in which the resource belongs.
                If it is not provided, the provider project is used.
+        :param pulumi.Input['ConnectionProfileSalesforceProfileArgs'] salesforce_profile: Salesforce profile.
+               Structure is documented below.
         :param pulumi.Input['ConnectionProfileSqlServerProfileArgs'] sql_server_profile: SQL Server database profile.
                Structure is documented below.
         """
@@ -88,6 +91,8 @@ class ConnectionProfileArgs:
             pulumi.set(__self__, "private_connectivity", private_connectivity)
         if project is not None:
             pulumi.set(__self__, "project", project)
+        if salesforce_profile is not None:
+            pulumi.set(__self__, "salesforce_profile", salesforce_profile)
         if sql_server_profile is not None:
             pulumi.set(__self__, "sql_server_profile", sql_server_profile)
 
@@ -259,6 +264,19 @@ class ConnectionProfileArgs:
     def project(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "project", value)
 
+    @property
+    @pulumi.getter(name="salesforceProfile")
+    def salesforce_profile(self) -> Optional[pulumi.Input['ConnectionProfileSalesforceProfileArgs']]:
+        """
+        Salesforce profile.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "salesforce_profile")
+
+    @salesforce_profile.setter
+    def salesforce_profile(self, value: Optional[pulumi.Input['ConnectionProfileSalesforceProfileArgs']]):
+        pulumi.set(self, "salesforce_profile", value)
+
     @property
     @pulumi.getter(name="sqlServerProfile")
     def sql_server_profile(self) -> Optional[pulumi.Input['ConnectionProfileSqlServerProfileArgs']]:
@@ -292,6 +310,7 @@ class _ConnectionProfileState:
                  private_connectivity: Optional[pulumi.Input['ConnectionProfilePrivateConnectivityArgs']] = None,
                  project: Optional[pulumi.Input[str]] = None,
                  pulumi_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 salesforce_profile: Optional[pulumi.Input['ConnectionProfileSalesforceProfileArgs']] = None,
                  sql_server_profile: Optional[pulumi.Input['ConnectionProfileSqlServerProfileArgs']] = None):
         """
         Input properties used for looking up and filtering ConnectionProfile resources.
@@ -324,6 +343,8 @@ class _ConnectionProfileState:
                If it is not provided, the provider project is used.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] pulumi_labels: The combination of labels configured directly on the resource
                and default labels configured on the provider.
+        :param pulumi.Input['ConnectionProfileSalesforceProfileArgs'] salesforce_profile: Salesforce profile.
+               Structure is documented below.
         :param pulumi.Input['ConnectionProfileSqlServerProfileArgs'] sql_server_profile: SQL Server database profile.
                Structure is documented below.
         """
@@ -359,6 +380,8 @@ class _ConnectionProfileState:
             pulumi.set(__self__, "project", project)
         if pulumi_labels is not None:
             pulumi.set(__self__, "pulumi_labels", pulumi_labels)
+        if salesforce_profile is not None:
+            pulumi.set(__self__, "salesforce_profile", salesforce_profile)
         if sql_server_profile is not None:
             pulumi.set(__self__, "sql_server_profile", sql_server_profile)
 
@@ -567,6 +590,19 @@ class _ConnectionProfileState:
     def pulumi_labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
         pulumi.set(self, "pulumi_labels", value)
 
+    @property
+    @pulumi.getter(name="salesforceProfile")
+    def salesforce_profile(self) -> Optional[pulumi.Input['ConnectionProfileSalesforceProfileArgs']]:
+        """
+        Salesforce profile.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "salesforce_profile")
+
+    @salesforce_profile.setter
+    def salesforce_profile(self, value: Optional[pulumi.Input['ConnectionProfileSalesforceProfileArgs']]):
+        pulumi.set(self, "salesforce_profile", value)
+
     @property
     @pulumi.getter(name="sqlServerProfile")
     def sql_server_profile(self) -> Optional[pulumi.Input['ConnectionProfileSqlServerProfileArgs']]:
@@ -599,6 +635,7 @@ class ConnectionProfile(pulumi.CustomResource):
                  postgresql_profile: Optional[pulumi.Input[Union['ConnectionProfilePostgresqlProfileArgs', 'ConnectionProfilePostgresqlProfileArgsDict']]] = None,
                  private_connectivity: Optional[pulumi.Input[Union['ConnectionProfilePrivateConnectivityArgs', 'ConnectionProfilePrivateConnectivityArgsDict']]] = None,
                  project: Optional[pulumi.Input[str]] = None,
+                 salesforce_profile: Optional[pulumi.Input[Union['ConnectionProfileSalesforceProfileArgs', 'ConnectionProfileSalesforceProfileArgsDict']]] = None,
                  sql_server_profile: Optional[pulumi.Input[Union['ConnectionProfileSqlServerProfileArgs', 'ConnectionProfileSqlServerProfileArgsDict']]] = None,
                  __props__=None):
         """
@@ -866,7 +903,6 @@ class ConnectionProfile(pulumi.CustomResource):
                 "database": db.name,
             })
         ```
-
         ## Import
 
         ConnectionProfile can be imported using any of these accepted formats:
@@ -918,6 +954,8 @@ class ConnectionProfile(pulumi.CustomResource):
                Structure is documented below.
         :param pulumi.Input[str] project: The ID of the project in which the resource belongs.
                If it is not provided, the provider project is used.
+        :param pulumi.Input[Union['ConnectionProfileSalesforceProfileArgs', 'ConnectionProfileSalesforceProfileArgsDict']] salesforce_profile: Salesforce profile.
+               Structure is documented below.
         :param pulumi.Input[Union['ConnectionProfileSqlServerProfileArgs', 'ConnectionProfileSqlServerProfileArgsDict']] sql_server_profile: SQL Server database profile.
                Structure is documented below.
         """
@@ -1192,7 +1230,6 @@ class ConnectionProfile(pulumi.CustomResource):
                 "database": db.name,
             })
         ```
-
         ## Import
 
         ConnectionProfile can be imported using any of these accepted formats:
@@ -1245,6 +1282,7 @@ class ConnectionProfile(pulumi.CustomResource):
                  postgresql_profile: Optional[pulumi.Input[Union['ConnectionProfilePostgresqlProfileArgs', 'ConnectionProfilePostgresqlProfileArgsDict']]] = None,
                  private_connectivity: Optional[pulumi.Input[Union['ConnectionProfilePrivateConnectivityArgs', 'ConnectionProfilePrivateConnectivityArgsDict']]] = None,
                  project: Optional[pulumi.Input[str]] = None,
+                 salesforce_profile: Optional[pulumi.Input[Union['ConnectionProfileSalesforceProfileArgs', 'ConnectionProfileSalesforceProfileArgsDict']]] = None,
                  sql_server_profile: Optional[pulumi.Input[Union['ConnectionProfileSqlServerProfileArgs', 'ConnectionProfileSqlServerProfileArgsDict']]] = None,
                  __props__=None):
         opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
@@ -1274,6 +1312,7 @@ class ConnectionProfile(pulumi.CustomResource):
             __props__.__dict__["postgresql_profile"] = postgresql_profile
             __props__.__dict__["private_connectivity"] = private_connectivity
             __props__.__dict__["project"] = project
+            __props__.__dict__["salesforce_profile"] = salesforce_profile
             __props__.__dict__["sql_server_profile"] = sql_server_profile
             __props__.__dict__["effective_labels"] = None
             __props__.__dict__["name"] = None
@@ -1306,6 +1345,7 @@ class ConnectionProfile(pulumi.CustomResource):
             private_connectivity: Optional[pulumi.Input[Union['ConnectionProfilePrivateConnectivityArgs', 'ConnectionProfilePrivateConnectivityArgsDict']]] = None,
             project: Optional[pulumi.Input[str]] = None,
             pulumi_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+            salesforce_profile: Optional[pulumi.Input[Union['ConnectionProfileSalesforceProfileArgs', 'ConnectionProfileSalesforceProfileArgsDict']]] = None,
             sql_server_profile: Optional[pulumi.Input[Union['ConnectionProfileSqlServerProfileArgs', 'ConnectionProfileSqlServerProfileArgsDict']]] = None) -> 'ConnectionProfile':
         """
         Get an existing ConnectionProfile resource's state with the given name, id, and optional extra
@@ -1343,6 +1383,8 @@ class ConnectionProfile(pulumi.CustomResource):
                If it is not provided, the provider project is used.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] pulumi_labels: The combination of labels configured directly on the resource
                and default labels configured on the provider.
+        :param pulumi.Input[Union['ConnectionProfileSalesforceProfileArgs', 'ConnectionProfileSalesforceProfileArgsDict']] salesforce_profile: Salesforce profile.
+               Structure is documented below.
         :param pulumi.Input[Union['ConnectionProfileSqlServerProfileArgs', 'ConnectionProfileSqlServerProfileArgsDict']] sql_server_profile: SQL Server database profile.
                Structure is documented below.
         """
@@ -1366,6 +1408,7 @@ class ConnectionProfile(pulumi.CustomResource):
         __props__.__dict__["private_connectivity"] = private_connectivity
         __props__.__dict__["project"] = project
         __props__.__dict__["pulumi_labels"] = pulumi_labels
+        __props__.__dict__["salesforce_profile"] = salesforce_profile
         __props__.__dict__["sql_server_profile"] = sql_server_profile
         return ConnectionProfile(resource_name, opts=opts, __props__=__props__)
 
@@ -1510,6 +1553,15 @@ class ConnectionProfile(pulumi.CustomResource):
         """
         return pulumi.get(self, "pulumi_labels")
 
+    @property
+    @pulumi.getter(name="salesforceProfile")
+    def salesforce_profile(self) -> pulumi.Output[Optional['outputs.ConnectionProfileSalesforceProfile']]:
+        """
+        Salesforce profile.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "salesforce_profile")
+
     @property
     @pulumi.getter(name="sqlServerProfile")
     def sql_server_profile(self) -> pulumi.Output[Optional['outputs.ConnectionProfileSqlServerProfile']]: