pulumi-gcp 8.14.0__py3-none-any.whl → 8.14.0a1736404082__py3-none-any.whl

pulumi_gcp/developerconnect/outputs.py

@@ -16,60 +16,11 @@ 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
@@ -101,19 +52,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:
@@ -127,12 +78,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")
 
@@ -148,8 +99,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")
@@ -159,8 +110,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")
 
@@ -188,8 +139,9 @@ 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.
         """
@@ -201,8 +153,9 @@ 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")
 
@@ -216,648 +169,6 @@ 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
@@ -882,10 +193,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:
@@ -906,8 +217,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")
 
@@ -915,8 +226,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")