pulumi-gcp 8.14.0a1736853524__py3-none-any.whl → 8.14.0a1736952890__py3-none-any.whl

pulumi_gcp/developerconnect/outputs.py

@@ -16,11 +16,60 @@ from .. import _utilities
 from . import outputs
 
 __all__ = [
+    'ConnectionCryptoKeyConfig',
     'ConnectionGithubConfig',
     'ConnectionGithubConfigAuthorizerCredential',
+    'ConnectionGithubEnterpriseConfig',
+    'ConnectionGithubEnterpriseConfigServiceDirectoryConfig',
+    'ConnectionGitlabConfig',
+    'ConnectionGitlabConfigAuthorizerCredential',
+    'ConnectionGitlabConfigReadAuthorizerCredential',
+    'ConnectionGitlabEnterpriseConfig',
+    'ConnectionGitlabEnterpriseConfigAuthorizerCredential',
+    'ConnectionGitlabEnterpriseConfigReadAuthorizerCredential',
+    'ConnectionGitlabEnterpriseConfigServiceDirectoryConfig',
     'ConnectionInstallationState',
 ]
 
+@pulumi.output_type
+class ConnectionCryptoKeyConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "keyReference":
+            suggest = "key_reference"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ConnectionCryptoKeyConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ConnectionCryptoKeyConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ConnectionCryptoKeyConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 key_reference: str):
+        """
+        :param str key_reference: Required. The name of the key which is used to encrypt/decrypt customer data. For key
+               in Cloud KMS, the key should be in the format of
+               `projects/*/locations/*/keyRings/*/cryptoKeys/*`.
+        """
+        pulumi.set(__self__, "key_reference", key_reference)
+
+    @property
+    @pulumi.getter(name="keyReference")
+    def key_reference(self) -> str:
+        """
+        Required. The name of the key which is used to encrypt/decrypt customer data. For key
+        in Cloud KMS, the key should be in the format of
+        `projects/*/locations/*/keyRings/*/cryptoKeys/*`.
+        """
+        return pulumi.get(self, "key_reference")
+
+
 @pulumi.output_type
 class ConnectionGithubConfig(dict):
     @staticmethod
@@ -52,19 +101,19 @@ class ConnectionGithubConfig(dict):
                  authorizer_credential: Optional['outputs.ConnectionGithubConfigAuthorizerCredential'] = None,
                  installation_uri: Optional[str] = None):
         """
-        :param str github_app: Required. Immutable. The GitHub Application that was installed to
-               the GitHub user or organization.
+        :param str github_app: Required. Immutable. The GitHub Application that was installed to the GitHub user or
+               organization.
                Possible values:
                GIT_HUB_APP_UNSPECIFIED
                DEVELOPER_CONNECT
-               FIREBASE"
+               FIREBASE
         :param str app_installation_id: Optional. GitHub App installation id.
-        :param 'ConnectionGithubConfigAuthorizerCredentialArgs' authorizer_credential: Represents an OAuth token of the account that authorized the Connection,and
-               associated metadata.
+        :param 'ConnectionGithubConfigAuthorizerCredentialArgs' authorizer_credential: Represents an OAuth token of the account that authorized the Connection,
+               and associated metadata.
                Structure is documented below.
         :param str installation_uri: (Output)
-               Output only. The URI to navigate to in order to manage the installation
-               associated with this GitHubConfig.
+               Output only. The URI to navigate to in order to manage the installation associated
+               with this GitHubConfig.
         """
         pulumi.set(__self__, "github_app", github_app)
         if app_installation_id is not None:
@@ -78,12 +127,12 @@ class ConnectionGithubConfig(dict):
     @pulumi.getter(name="githubApp")
     def github_app(self) -> str:
         """
-        Required. Immutable. The GitHub Application that was installed to
-        the GitHub user or organization.
+        Required. Immutable. The GitHub Application that was installed to the GitHub user or
+        organization.
         Possible values:
         GIT_HUB_APP_UNSPECIFIED
         DEVELOPER_CONNECT
-        FIREBASE"
+        FIREBASE
         """
         return pulumi.get(self, "github_app")
 
@@ -99,8 +148,8 @@ class ConnectionGithubConfig(dict):
     @pulumi.getter(name="authorizerCredential")
     def authorizer_credential(self) -> Optional['outputs.ConnectionGithubConfigAuthorizerCredential']:
         """
-        Represents an OAuth token of the account that authorized the Connection,and
-        associated metadata.
+        Represents an OAuth token of the account that authorized the Connection,
+        and associated metadata.
         Structure is documented below.
         """
         return pulumi.get(self, "authorizer_credential")
@@ -110,8 +159,8 @@ class ConnectionGithubConfig(dict):
     def installation_uri(self) -> Optional[str]:
         """
         (Output)
-        Output only. The URI to navigate to in order to manage the installation
-        associated with this GitHubConfig.
+        Output only. The URI to navigate to in order to manage the installation associated
+        with this GitHubConfig.
         """
         return pulumi.get(self, "installation_uri")
 
@@ -139,9 +188,8 @@ class ConnectionGithubConfigAuthorizerCredential(dict):
                  oauth_token_secret_version: str,
                  username: Optional[str] = None):
         """
-        :param str oauth_token_secret_version: Required. A SecretManager resource containing the OAuth token
-               that authorizes the connection.
-               Format: `projects/*/secrets/*/versions/*`.
+        :param str oauth_token_secret_version: Required. A SecretManager resource containing the OAuth token that authorizes
+               the connection. Format: `projects/*/secrets/*/versions/*`.
         :param str username: (Output)
                Output only. The username associated with this token.
         """
@@ -153,9 +201,8 @@ class ConnectionGithubConfigAuthorizerCredential(dict):
     @pulumi.getter(name="oauthTokenSecretVersion")
     def oauth_token_secret_version(self) -> str:
         """
-        Required. A SecretManager resource containing the OAuth token
-        that authorizes the connection.
-        Format: `projects/*/secrets/*/versions/*`.
+        Required. A SecretManager resource containing the OAuth token that authorizes
+        the connection. Format: `projects/*/secrets/*/versions/*`.
         """
         return pulumi.get(self, "oauth_token_secret_version")
 
@@ -169,6 +216,648 @@ class ConnectionGithubConfigAuthorizerCredential(dict):
         return pulumi.get(self, "username")
 
 
+@pulumi.output_type
+class ConnectionGithubEnterpriseConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "hostUri":
+            suggest = "host_uri"
+        elif key == "appId":
+            suggest = "app_id"
+        elif key == "appInstallationId":
+            suggest = "app_installation_id"
+        elif key == "appSlug":
+            suggest = "app_slug"
+        elif key == "installationUri":
+            suggest = "installation_uri"
+        elif key == "privateKeySecretVersion":
+            suggest = "private_key_secret_version"
+        elif key == "serverVersion":
+            suggest = "server_version"
+        elif key == "serviceDirectoryConfig":
+            suggest = "service_directory_config"
+        elif key == "sslCaCertificate":
+            suggest = "ssl_ca_certificate"
+        elif key == "webhookSecretSecretVersion":
+            suggest = "webhook_secret_secret_version"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ConnectionGithubEnterpriseConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ConnectionGithubEnterpriseConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ConnectionGithubEnterpriseConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 host_uri: str,
+                 app_id: Optional[str] = None,
+                 app_installation_id: Optional[str] = None,
+                 app_slug: Optional[str] = None,
+                 installation_uri: Optional[str] = None,
+                 private_key_secret_version: Optional[str] = None,
+                 server_version: Optional[str] = None,
+                 service_directory_config: Optional['outputs.ConnectionGithubEnterpriseConfigServiceDirectoryConfig'] = None,
+                 ssl_ca_certificate: Optional[str] = None,
+                 webhook_secret_secret_version: Optional[str] = None):
+        """
+        :param str host_uri: Required. The URI of the GitHub Enterprise host this connection is for.
+        :param str app_id: Optional. ID of the GitHub App created from the manifest.
+        :param str app_installation_id: Optional. ID of the installation of the GitHub App.
+        :param str app_slug: (Output)
+               Output only. The URL-friendly name of the GitHub App.
+        :param str installation_uri: (Output)
+               Output only. The URI to navigate to in order to manage the installation associated
+               with this GitHubEnterpriseConfig.
+        :param str private_key_secret_version: Optional. SecretManager resource containing the private key of the GitHub App,
+               formatted as `projects/*/secrets/*/versions/*`.
+        :param str server_version: (Output)
+               Output only. GitHub Enterprise version installed at the host_uri.
+        :param 'ConnectionGithubEnterpriseConfigServiceDirectoryConfigArgs' service_directory_config: ServiceDirectoryConfig represents Service Directory configuration for a
+               connection.
+               Structure is documented below.
+        :param str ssl_ca_certificate: Optional. SSL certificate to use for requests to GitHub Enterprise.
+        :param str webhook_secret_secret_version: Optional. SecretManager resource containing the webhook secret of the GitHub App,
+               formatted as `projects/*/secrets/*/versions/*`.
+        """
+        pulumi.set(__self__, "host_uri", host_uri)
+        if app_id is not None:
+            pulumi.set(__self__, "app_id", app_id)
+        if app_installation_id is not None:
+            pulumi.set(__self__, "app_installation_id", app_installation_id)
+        if app_slug is not None:
+            pulumi.set(__self__, "app_slug", app_slug)
+        if installation_uri is not None:
+            pulumi.set(__self__, "installation_uri", installation_uri)
+        if private_key_secret_version is not None:
+            pulumi.set(__self__, "private_key_secret_version", private_key_secret_version)
+        if server_version is not None:
+            pulumi.set(__self__, "server_version", server_version)
+        if service_directory_config is not None:
+            pulumi.set(__self__, "service_directory_config", service_directory_config)
+        if ssl_ca_certificate is not None:
+            pulumi.set(__self__, "ssl_ca_certificate", ssl_ca_certificate)
+        if webhook_secret_secret_version is not None:
+            pulumi.set(__self__, "webhook_secret_secret_version", webhook_secret_secret_version)
+
+    @property
+    @pulumi.getter(name="hostUri")
+    def host_uri(self) -> str:
+        """
+        Required. The URI of the GitHub Enterprise host this connection is for.
+        """
+        return pulumi.get(self, "host_uri")
+
+    @property
+    @pulumi.getter(name="appId")
+    def app_id(self) -> Optional[str]:
+        """
+        Optional. ID of the GitHub App created from the manifest.
+        """
+        return pulumi.get(self, "app_id")
+
+    @property
+    @pulumi.getter(name="appInstallationId")
+    def app_installation_id(self) -> Optional[str]:
+        """
+        Optional. ID of the installation of the GitHub App.
+        """
+        return pulumi.get(self, "app_installation_id")
+
+    @property
+    @pulumi.getter(name="appSlug")
+    def app_slug(self) -> Optional[str]:
+        """
+        (Output)
+        Output only. The URL-friendly name of the GitHub App.
+        """
+        return pulumi.get(self, "app_slug")
+
+    @property
+    @pulumi.getter(name="installationUri")
+    def installation_uri(self) -> Optional[str]:
+        """
+        (Output)
+        Output only. The URI to navigate to in order to manage the installation associated
+        with this GitHubEnterpriseConfig.
+        """
+        return pulumi.get(self, "installation_uri")
+
+    @property
+    @pulumi.getter(name="privateKeySecretVersion")
+    def private_key_secret_version(self) -> Optional[str]:
+        """
+        Optional. SecretManager resource containing the private key of the GitHub App,
+        formatted as `projects/*/secrets/*/versions/*`.
+        """
+        return pulumi.get(self, "private_key_secret_version")
+
+    @property
+    @pulumi.getter(name="serverVersion")
+    def server_version(self) -> Optional[str]:
+        """
+        (Output)
+        Output only. GitHub Enterprise version installed at the host_uri.
+        """
+        return pulumi.get(self, "server_version")
+
+    @property
+    @pulumi.getter(name="serviceDirectoryConfig")
+    def service_directory_config(self) -> Optional['outputs.ConnectionGithubEnterpriseConfigServiceDirectoryConfig']:
+        """
+        ServiceDirectoryConfig represents Service Directory configuration for a
+        connection.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "service_directory_config")
+
+    @property
+    @pulumi.getter(name="sslCaCertificate")
+    def ssl_ca_certificate(self) -> Optional[str]:
+        """
+        Optional. SSL certificate to use for requests to GitHub Enterprise.
+        """
+        return pulumi.get(self, "ssl_ca_certificate")
+
+    @property
+    @pulumi.getter(name="webhookSecretSecretVersion")
+    def webhook_secret_secret_version(self) -> Optional[str]:
+        """
+        Optional. SecretManager resource containing the webhook secret of the GitHub App,
+        formatted as `projects/*/secrets/*/versions/*`.
+        """
+        return pulumi.get(self, "webhook_secret_secret_version")
+
+
+@pulumi.output_type
+class ConnectionGithubEnterpriseConfigServiceDirectoryConfig(dict):
+    def __init__(__self__, *,
+                 service: str):
+        """
+        :param str service: Required. The Service Directory service name.
+               Format:
+               projects/{project}/locations/{location}/namespaces/{namespace}/services/{service}.
+        """
+        pulumi.set(__self__, "service", service)
+
+    @property
+    @pulumi.getter
+    def service(self) -> str:
+        """
+        Required. The Service Directory service name.
+        Format:
+        projects/{project}/locations/{location}/namespaces/{namespace}/services/{service}.
+        """
+        return pulumi.get(self, "service")
+
+
+@pulumi.output_type
+class ConnectionGitlabConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "authorizerCredential":
+            suggest = "authorizer_credential"
+        elif key == "readAuthorizerCredential":
+            suggest = "read_authorizer_credential"
+        elif key == "webhookSecretSecretVersion":
+            suggest = "webhook_secret_secret_version"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ConnectionGitlabConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ConnectionGitlabConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ConnectionGitlabConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 authorizer_credential: 'outputs.ConnectionGitlabConfigAuthorizerCredential',
+                 read_authorizer_credential: 'outputs.ConnectionGitlabConfigReadAuthorizerCredential',
+                 webhook_secret_secret_version: str):
+        """
+        :param 'ConnectionGitlabConfigAuthorizerCredentialArgs' authorizer_credential: Represents a personal access token that authorized the Connection,
+               and associated metadata.
+               Structure is documented below.
+        :param 'ConnectionGitlabConfigReadAuthorizerCredentialArgs' read_authorizer_credential: Represents a personal access token that authorized the Connection,
+               and associated metadata.
+               Structure is documented below.
+        :param str webhook_secret_secret_version: Required. Immutable. SecretManager resource containing the webhook secret of a GitLab project,
+               formatted as `projects/*/secrets/*/versions/*`. This is used to validate
+               webhooks.
+        """
+        pulumi.set(__self__, "authorizer_credential", authorizer_credential)
+        pulumi.set(__self__, "read_authorizer_credential", read_authorizer_credential)
+        pulumi.set(__self__, "webhook_secret_secret_version", webhook_secret_secret_version)
+
+    @property
+    @pulumi.getter(name="authorizerCredential")
+    def authorizer_credential(self) -> 'outputs.ConnectionGitlabConfigAuthorizerCredential':
+        """
+        Represents a personal access token that authorized the Connection,
+        and associated metadata.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "authorizer_credential")
+
+    @property
+    @pulumi.getter(name="readAuthorizerCredential")
+    def read_authorizer_credential(self) -> 'outputs.ConnectionGitlabConfigReadAuthorizerCredential':
+        """
+        Represents a personal access token that authorized the Connection,
+        and associated metadata.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "read_authorizer_credential")
+
+    @property
+    @pulumi.getter(name="webhookSecretSecretVersion")
+    def webhook_secret_secret_version(self) -> str:
+        """
+        Required. Immutable. SecretManager resource containing the webhook secret of a GitLab project,
+        formatted as `projects/*/secrets/*/versions/*`. This is used to validate
+        webhooks.
+        """
+        return pulumi.get(self, "webhook_secret_secret_version")
+
+
+@pulumi.output_type
+class ConnectionGitlabConfigAuthorizerCredential(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "userTokenSecretVersion":
+            suggest = "user_token_secret_version"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ConnectionGitlabConfigAuthorizerCredential. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ConnectionGitlabConfigAuthorizerCredential.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ConnectionGitlabConfigAuthorizerCredential.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 user_token_secret_version: str,
+                 username: Optional[str] = None):
+        """
+        :param str user_token_secret_version: Required. A SecretManager resource containing the user token that authorizes
+               the Developer Connect connection. Format:
+               `projects/*/secrets/*/versions/*`.
+        :param str username: (Output)
+               Output only. The username associated with this token.
+        """
+        pulumi.set(__self__, "user_token_secret_version", user_token_secret_version)
+        if username is not None:
+            pulumi.set(__self__, "username", username)
+
+    @property
+    @pulumi.getter(name="userTokenSecretVersion")
+    def user_token_secret_version(self) -> str:
+        """
+        Required. A SecretManager resource containing the user token that authorizes
+        the Developer Connect connection. Format:
+        `projects/*/secrets/*/versions/*`.
+        """
+        return pulumi.get(self, "user_token_secret_version")
+
+    @property
+    @pulumi.getter
+    def username(self) -> Optional[str]:
+        """
+        (Output)
+        Output only. The username associated with this token.
+        """
+        return pulumi.get(self, "username")
+
+
+@pulumi.output_type
+class ConnectionGitlabConfigReadAuthorizerCredential(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "userTokenSecretVersion":
+            suggest = "user_token_secret_version"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ConnectionGitlabConfigReadAuthorizerCredential. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ConnectionGitlabConfigReadAuthorizerCredential.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ConnectionGitlabConfigReadAuthorizerCredential.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 user_token_secret_version: str,
+                 username: Optional[str] = None):
+        """
+        :param str user_token_secret_version: Required. A SecretManager resource containing the user token that authorizes
+               the Developer Connect connection. Format:
+               `projects/*/secrets/*/versions/*`.
+        :param str username: (Output)
+               Output only. The username associated with this token.
+        """
+        pulumi.set(__self__, "user_token_secret_version", user_token_secret_version)
+        if username is not None:
+            pulumi.set(__self__, "username", username)
+
+    @property
+    @pulumi.getter(name="userTokenSecretVersion")
+    def user_token_secret_version(self) -> str:
+        """
+        Required. A SecretManager resource containing the user token that authorizes
+        the Developer Connect connection. Format:
+        `projects/*/secrets/*/versions/*`.
+        """
+        return pulumi.get(self, "user_token_secret_version")
+
+    @property
+    @pulumi.getter
+    def username(self) -> Optional[str]:
+        """
+        (Output)
+        Output only. The username associated with this token.
+        """
+        return pulumi.get(self, "username")
+
+
+@pulumi.output_type
+class ConnectionGitlabEnterpriseConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "authorizerCredential":
+            suggest = "authorizer_credential"
+        elif key == "hostUri":
+            suggest = "host_uri"
+        elif key == "readAuthorizerCredential":
+            suggest = "read_authorizer_credential"
+        elif key == "webhookSecretSecretVersion":
+            suggest = "webhook_secret_secret_version"
+        elif key == "serverVersion":
+            suggest = "server_version"
+        elif key == "serviceDirectoryConfig":
+            suggest = "service_directory_config"
+        elif key == "sslCaCertificate":
+            suggest = "ssl_ca_certificate"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ConnectionGitlabEnterpriseConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ConnectionGitlabEnterpriseConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ConnectionGitlabEnterpriseConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 authorizer_credential: 'outputs.ConnectionGitlabEnterpriseConfigAuthorizerCredential',
+                 host_uri: str,
+                 read_authorizer_credential: 'outputs.ConnectionGitlabEnterpriseConfigReadAuthorizerCredential',
+                 webhook_secret_secret_version: str,
+                 server_version: Optional[str] = None,
+                 service_directory_config: Optional['outputs.ConnectionGitlabEnterpriseConfigServiceDirectoryConfig'] = None,
+                 ssl_ca_certificate: Optional[str] = None):
+        """
+        :param 'ConnectionGitlabEnterpriseConfigAuthorizerCredentialArgs' authorizer_credential: Represents a personal access token that authorized the Connection,
+               and associated metadata.
+               Structure is documented below.
+        :param str host_uri: Required. The URI of the GitLab Enterprise host this connection is for.
+        :param 'ConnectionGitlabEnterpriseConfigReadAuthorizerCredentialArgs' read_authorizer_credential: Represents a personal access token that authorized the Connection,
+               and associated metadata.
+               Structure is documented below.
+        :param str webhook_secret_secret_version: Required. Immutable. SecretManager resource containing the webhook secret of a GitLab project,
+               formatted as `projects/*/secrets/*/versions/*`. This is used to validate
+               webhooks.
+        :param str server_version: (Output)
+               Output only. Version of the GitLab Enterprise server running on the `host_uri`.
+        :param 'ConnectionGitlabEnterpriseConfigServiceDirectoryConfigArgs' service_directory_config: ServiceDirectoryConfig represents Service Directory configuration for a
+               connection.
+               Structure is documented below.
+        :param str ssl_ca_certificate: Optional. SSL Certificate Authority certificate to use for requests to GitLab
+               Enterprise instance.
+        """
+        pulumi.set(__self__, "authorizer_credential", authorizer_credential)
+        pulumi.set(__self__, "host_uri", host_uri)
+        pulumi.set(__self__, "read_authorizer_credential", read_authorizer_credential)
+        pulumi.set(__self__, "webhook_secret_secret_version", webhook_secret_secret_version)
+        if server_version is not None:
+            pulumi.set(__self__, "server_version", server_version)
+        if service_directory_config is not None:
+            pulumi.set(__self__, "service_directory_config", service_directory_config)
+        if ssl_ca_certificate is not None:
+            pulumi.set(__self__, "ssl_ca_certificate", ssl_ca_certificate)
+
+    @property
+    @pulumi.getter(name="authorizerCredential")
+    def authorizer_credential(self) -> 'outputs.ConnectionGitlabEnterpriseConfigAuthorizerCredential':
+        """
+        Represents a personal access token that authorized the Connection,
+        and associated metadata.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "authorizer_credential")
+
+    @property
+    @pulumi.getter(name="hostUri")
+    def host_uri(self) -> str:
+        """
+        Required. The URI of the GitLab Enterprise host this connection is for.
+        """
+        return pulumi.get(self, "host_uri")
+
+    @property
+    @pulumi.getter(name="readAuthorizerCredential")
+    def read_authorizer_credential(self) -> 'outputs.ConnectionGitlabEnterpriseConfigReadAuthorizerCredential':
+        """
+        Represents a personal access token that authorized the Connection,
+        and associated metadata.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "read_authorizer_credential")
+
+    @property
+    @pulumi.getter(name="webhookSecretSecretVersion")
+    def webhook_secret_secret_version(self) -> str:
+        """
+        Required. Immutable. SecretManager resource containing the webhook secret of a GitLab project,
+        formatted as `projects/*/secrets/*/versions/*`. This is used to validate
+        webhooks.
+        """
+        return pulumi.get(self, "webhook_secret_secret_version")
+
+    @property
+    @pulumi.getter(name="serverVersion")
+    def server_version(self) -> Optional[str]:
+        """
+        (Output)
+        Output only. Version of the GitLab Enterprise server running on the `host_uri`.
+        """
+        return pulumi.get(self, "server_version")
+
+    @property
+    @pulumi.getter(name="serviceDirectoryConfig")
+    def service_directory_config(self) -> Optional['outputs.ConnectionGitlabEnterpriseConfigServiceDirectoryConfig']:
+        """
+        ServiceDirectoryConfig represents Service Directory configuration for a
+        connection.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "service_directory_config")
+
+    @property
+    @pulumi.getter(name="sslCaCertificate")
+    def ssl_ca_certificate(self) -> Optional[str]:
+        """
+        Optional. SSL Certificate Authority certificate to use for requests to GitLab
+        Enterprise instance.
+        """
+        return pulumi.get(self, "ssl_ca_certificate")
+
+
+@pulumi.output_type
+class ConnectionGitlabEnterpriseConfigAuthorizerCredential(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "userTokenSecretVersion":
+            suggest = "user_token_secret_version"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ConnectionGitlabEnterpriseConfigAuthorizerCredential. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ConnectionGitlabEnterpriseConfigAuthorizerCredential.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ConnectionGitlabEnterpriseConfigAuthorizerCredential.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 user_token_secret_version: str,
+                 username: Optional[str] = None):
+        """
+        :param str user_token_secret_version: Required. A SecretManager resource containing the user token that authorizes
+               the Developer Connect connection. Format:
+               `projects/*/secrets/*/versions/*`.
+        :param str username: (Output)
+               Output only. The username associated with this token.
+        """
+        pulumi.set(__self__, "user_token_secret_version", user_token_secret_version)
+        if username is not None:
+            pulumi.set(__self__, "username", username)
+
+    @property
+    @pulumi.getter(name="userTokenSecretVersion")
+    def user_token_secret_version(self) -> str:
+        """
+        Required. A SecretManager resource containing the user token that authorizes
+        the Developer Connect connection. Format:
+        `projects/*/secrets/*/versions/*`.
+        """
+        return pulumi.get(self, "user_token_secret_version")
+
+    @property
+    @pulumi.getter
+    def username(self) -> Optional[str]:
+        """
+        (Output)
+        Output only. The username associated with this token.
+        """
+        return pulumi.get(self, "username")
+
+
+@pulumi.output_type
+class ConnectionGitlabEnterpriseConfigReadAuthorizerCredential(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "userTokenSecretVersion":
+            suggest = "user_token_secret_version"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ConnectionGitlabEnterpriseConfigReadAuthorizerCredential. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ConnectionGitlabEnterpriseConfigReadAuthorizerCredential.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ConnectionGitlabEnterpriseConfigReadAuthorizerCredential.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 user_token_secret_version: str,
+                 username: Optional[str] = None):
+        """
+        :param str user_token_secret_version: Required. A SecretManager resource containing the user token that authorizes
+               the Developer Connect connection. Format:
+               `projects/*/secrets/*/versions/*`.
+        :param str username: (Output)
+               Output only. The username associated with this token.
+        """
+        pulumi.set(__self__, "user_token_secret_version", user_token_secret_version)
+        if username is not None:
+            pulumi.set(__self__, "username", username)
+
+    @property
+    @pulumi.getter(name="userTokenSecretVersion")
+    def user_token_secret_version(self) -> str:
+        """
+        Required. A SecretManager resource containing the user token that authorizes
+        the Developer Connect connection. Format:
+        `projects/*/secrets/*/versions/*`.
+        """
+        return pulumi.get(self, "user_token_secret_version")
+
+    @property
+    @pulumi.getter
+    def username(self) -> Optional[str]:
+        """
+        (Output)
+        Output only. The username associated with this token.
+        """
+        return pulumi.get(self, "username")
+
+
+@pulumi.output_type
+class ConnectionGitlabEnterpriseConfigServiceDirectoryConfig(dict):
+    def __init__(__self__, *,
+                 service: str):
+        """
+        :param str service: Required. The Service Directory service name.
+               Format:
+               projects/{project}/locations/{location}/namespaces/{namespace}/services/{service}.
+        """
+        pulumi.set(__self__, "service", service)
+
+    @property
+    @pulumi.getter
+    def service(self) -> str:
+        """
+        Required. The Service Directory service name.
+        Format:
+        projects/{project}/locations/{location}/namespaces/{namespace}/services/{service}.
+        """
+        return pulumi.get(self, "service")
+
+
 @pulumi.output_type
 class ConnectionInstallationState(dict):
     @staticmethod
@@ -193,10 +882,10 @@ class ConnectionInstallationState(dict):
                  message: Optional[str] = None,
                  stage: Optional[str] = None):
         """
-        :param str action_uri: Output only. Link to follow for next action. Empty string if the
-               installation is already complete.
-        :param str message: Output only. Message of what the user should do next to continue
-               the installation.Empty string if the installation is already complete.
+        :param str action_uri: Output only. Link to follow for next action. Empty string if the installation is already
+               complete.
+        :param str message: Output only. Message of what the user should do next to continue the installation.
+               Empty string if the installation is already complete.
         :param str stage: (Output)
                Output only. Current step of the installation process.
                Possible values:
@@ -217,8 +906,8 @@ class ConnectionInstallationState(dict):
     @pulumi.getter(name="actionUri")
     def action_uri(self) -> Optional[str]:
         """
-        Output only. Link to follow for next action. Empty string if the
-        installation is already complete.
+        Output only. Link to follow for next action. Empty string if the installation is already
+        complete.
         """
         return pulumi.get(self, "action_uri")
 
@@ -226,8 +915,8 @@ class ConnectionInstallationState(dict):
     @pulumi.getter
     def message(self) -> Optional[str]:
         """
-        Output only. Message of what the user should do next to continue
-        the installation.Empty string if the installation is already complete.
+        Output only. Message of what the user should do next to continue the installation.
+        Empty string if the installation is already complete.
         """
         return pulumi.get(self, "message")