# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'SpringCloudApiPortalSso',
    'SpringCloudAppCustomPersistentDisk',
    'SpringCloudAppIdentity',
    'SpringCloudAppPersistentDisk',
    'SpringCloudBuildDeploymentQuota',
    'SpringCloudBuildPackBindingLaunch',
    'SpringCloudBuilderBuildPackGroup',
    'SpringCloudBuilderStack',
    'SpringCloudConfigurationServiceRepository',
    'SpringCloudContainerDeploymentQuota',
    'SpringCloudGatewayApiMetadata',
    'SpringCloudGatewayCors',
    'SpringCloudGatewayQuota',
    'SpringCloudGatewayRouteConfigRoute',
    'SpringCloudGatewaySso',
    'SpringCloudJavaDeploymentQuota',
    'SpringCloudServiceConfigServerGitSetting',
    'SpringCloudServiceConfigServerGitSettingHttpBasicAuth',
    'SpringCloudServiceConfigServerGitSettingRepository',
    'SpringCloudServiceConfigServerGitSettingRepositoryHttpBasicAuth',
    'SpringCloudServiceConfigServerGitSettingRepositorySshAuth',
    'SpringCloudServiceConfigServerGitSettingSshAuth',
    'SpringCloudServiceNetwork',
    'SpringCloudServiceRequiredNetworkTrafficRule',
    'SpringCloudServiceTrace',
    'GetSpringCloudAppIdentityResult',
    'GetSpringCloudAppPersistentDiskResult',
    'GetSpringCloudServiceConfigServerGitSettingResult',
    'GetSpringCloudServiceConfigServerGitSettingHttpBasicAuthResult',
    'GetSpringCloudServiceConfigServerGitSettingRepositoryResult',
    'GetSpringCloudServiceConfigServerGitSettingRepositoryHttpBasicAuthResult',
    'GetSpringCloudServiceConfigServerGitSettingRepositorySshAuthResult',
    'GetSpringCloudServiceConfigServerGitSettingSshAuthResult',
    'GetSpringCloudServiceRequiredNetworkTrafficRuleResult',
]

@pulumi.output_type
class SpringCloudApiPortalSso(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientId":
            suggest = "client_id"
        elif key == "clientSecret":
            suggest = "client_secret"
        elif key == "issuerUri":
            suggest = "issuer_uri"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpringCloudApiPortalSso. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpringCloudApiPortalSso.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpringCloudApiPortalSso.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 client_id: Optional[str] = None,
                 client_secret: Optional[str] = None,
                 issuer_uri: Optional[str] = None,
                 scopes: Optional[Sequence[str]] = None):
        """
        :param str client_id: The public identifier for the application.
        :param str client_secret: The secret known only to the application and the authorization server.
        :param str issuer_uri: The URI of Issuer Identifier.
        :param Sequence[str] scopes: It defines the specific actions applications can be allowed to do on a user's behalf.
        """
        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 issuer_uri is not None:
            pulumi.set(__self__, "issuer_uri", issuer_uri)
        if scopes is not None:
            pulumi.set(__self__, "scopes", scopes)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> Optional[str]:
        """
        The public identifier for the application.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> Optional[str]:
        """
        The secret known only to the application and the authorization server.
        """
        return pulumi.get(self, "client_secret")

    @property
    @pulumi.getter(name="issuerUri")
    def issuer_uri(self) -> Optional[str]:
        """
        The URI of Issuer Identifier.
        """
        return pulumi.get(self, "issuer_uri")

    @property
    @pulumi.getter
    def scopes(self) -> Optional[Sequence[str]]:
        """
        It defines the specific actions applications can be allowed to do on a user's behalf.
        """
        return pulumi.get(self, "scopes")


@pulumi.output_type
class SpringCloudAppCustomPersistentDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "mountPath":
            suggest = "mount_path"
        elif key == "shareName":
            suggest = "share_name"
        elif key == "storageName":
            suggest = "storage_name"
        elif key == "mountOptions":
            suggest = "mount_options"
        elif key == "readOnlyEnabled":
            suggest = "read_only_enabled"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpringCloudAppCustomPersistentDisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpringCloudAppCustomPersistentDisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpringCloudAppCustomPersistentDisk.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 mount_path: str,
                 share_name: str,
                 storage_name: str,
                 mount_options: Optional[Sequence[str]] = None,
                 read_only_enabled: Optional[bool] = None):
        """
        :param str mount_path: The mount path of the persistent disk.
        :param str share_name: The share name of the Azure File share.
        :param str storage_name: The name of the Spring Cloud Storage.
        :param Sequence[str] mount_options: These are the mount options for a persistent disk.
        :param bool read_only_enabled: Indicates whether the persistent disk is a readOnly one.
        """
        pulumi.set(__self__, "mount_path", mount_path)
        pulumi.set(__self__, "share_name", share_name)
        pulumi.set(__self__, "storage_name", storage_name)
        if mount_options is not None:
            pulumi.set(__self__, "mount_options", mount_options)
        if read_only_enabled is not None:
            pulumi.set(__self__, "read_only_enabled", read_only_enabled)

    @property
    @pulumi.getter(name="mountPath")
    def mount_path(self) -> str:
        """
        The mount path of the persistent disk.
        """
        return pulumi.get(self, "mount_path")

    @property
    @pulumi.getter(name="shareName")
    def share_name(self) -> str:
        """
        The share name of the Azure File share.
        """
        return pulumi.get(self, "share_name")

    @property
    @pulumi.getter(name="storageName")
    def storage_name(self) -> str:
        """
        The name of the Spring Cloud Storage.
        """
        return pulumi.get(self, "storage_name")

    @property
    @pulumi.getter(name="mountOptions")
    def mount_options(self) -> Optional[Sequence[str]]:
        """
        These are the mount options for a persistent disk.
        """
        return pulumi.get(self, "mount_options")

    @property
    @pulumi.getter(name="readOnlyEnabled")
    def read_only_enabled(self) -> Optional[bool]:
        """
        Indicates whether the persistent disk is a readOnly one.
        """
        return pulumi.get(self, "read_only_enabled")


@pulumi.output_type
class SpringCloudAppIdentity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "identityIds":
            suggest = "identity_ids"
        elif key == "principalId":
            suggest = "principal_id"
        elif key == "tenantId":
            suggest = "tenant_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpringCloudAppIdentity. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpringCloudAppIdentity.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpringCloudAppIdentity.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 type: str,
                 identity_ids: Optional[Sequence[str]] = None,
                 principal_id: Optional[str] = None,
                 tenant_id: Optional[str] = None):
        """
        :param str type: Specifies the type of Managed Service Identity that should be configured on this Spring Cloud Application. Possible values are `SystemAssigned`, `UserAssigned`, `SystemAssigned, UserAssigned` (to enable both).
        :param Sequence[str] identity_ids: A list of User Assigned Managed Identity IDs to be assigned to this Spring Cloud Application.
        :param str principal_id: The Principal ID for the Service Principal associated with the Managed Service Identity of this Spring Cloud Application.
        :param str tenant_id: The Tenant ID for the Service Principal associated with the Managed Service Identity of this Spring Cloud Application.
        """
        pulumi.set(__self__, "type", type)
        if identity_ids is not None:
            pulumi.set(__self__, "identity_ids", identity_ids)
        if principal_id is not None:
            pulumi.set(__self__, "principal_id", principal_id)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Specifies the type of Managed Service Identity that should be configured on this Spring Cloud Application. Possible values are `SystemAssigned`, `UserAssigned`, `SystemAssigned, UserAssigned` (to enable both).
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="identityIds")
    def identity_ids(self) -> Optional[Sequence[str]]:
        """
        A list of User Assigned Managed Identity IDs to be assigned to this Spring Cloud Application.
        """
        return pulumi.get(self, "identity_ids")

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> Optional[str]:
        """
        The Principal ID for the Service Principal associated with the Managed Service Identity of this Spring Cloud Application.
        """
        return pulumi.get(self, "principal_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[str]:
        """
        The Tenant ID for the Service Principal associated with the Managed Service Identity of this Spring Cloud Application.
        """
        return pulumi.get(self, "tenant_id")


@pulumi.output_type
class SpringCloudAppPersistentDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sizeInGb":
            suggest = "size_in_gb"
        elif key == "mountPath":
            suggest = "mount_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpringCloudAppPersistentDisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpringCloudAppPersistentDisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpringCloudAppPersistentDisk.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 size_in_gb: int,
                 mount_path: Optional[str] = None):
        """
        :param int size_in_gb: Specifies the size of the persistent disk in GB. Possible values are between `0` and `50`.
        :param str mount_path: Specifies the mount path of the persistent disk. Defaults to `/persistent`.
        """
        pulumi.set(__self__, "size_in_gb", size_in_gb)
        if mount_path is not None:
            pulumi.set(__self__, "mount_path", mount_path)

    @property
    @pulumi.getter(name="sizeInGb")
    def size_in_gb(self) -> int:
        """
        Specifies the size of the persistent disk in GB. Possible values are between `0` and `50`.
        """
        return pulumi.get(self, "size_in_gb")

    @property
    @pulumi.getter(name="mountPath")
    def mount_path(self) -> Optional[str]:
        """
        Specifies the mount path of the persistent disk. Defaults to `/persistent`.
        """
        return pulumi.get(self, "mount_path")


@pulumi.output_type
class SpringCloudBuildDeploymentQuota(dict):
    def __init__(__self__, *,
                 cpu: Optional[str] = None,
                 memory: Optional[str] = None):
        """
        :param str cpu: Specifies the required cpu of the Spring Cloud Deployment. Possible Values are `500m`, `1`, `2`, `3` and `4`. Defaults to `1` if not specified.
        :param str memory: Specifies the required memory size of the Spring Cloud Deployment. Possible Values are `512Mi`, `1Gi`, `2Gi`, `3Gi`, `4Gi`, `5Gi`, `6Gi`, `7Gi`, and `8Gi`. Defaults to `1Gi` if not specified.
        """
        if cpu is not None:
            pulumi.set(__self__, "cpu", cpu)
        if memory is not None:
            pulumi.set(__self__, "memory", memory)

    @property
    @pulumi.getter
    def cpu(self) -> Optional[str]:
        """
        Specifies the required cpu of the Spring Cloud Deployment. Possible Values are `500m`, `1`, `2`, `3` and `4`. Defaults to `1` if not specified.
        """
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter
    def memory(self) -> Optional[str]:
        """
        Specifies the required memory size of the Spring Cloud Deployment. Possible Values are `512Mi`, `1Gi`, `2Gi`, `3Gi`, `4Gi`, `5Gi`, `6Gi`, `7Gi`, and `8Gi`. Defaults to `1Gi` if not specified.
        """
        return pulumi.get(self, "memory")


@pulumi.output_type
class SpringCloudBuildPackBindingLaunch(dict):
    def __init__(__self__, *,
                 properties: Optional[Mapping[str, str]] = None,
                 secrets: Optional[Mapping[str, str]] = None):
        """
        :param Mapping[str, str] properties: Specifies a map of non-sensitive properties for launchProperties.
        :param Mapping[str, str] secrets: Specifies a map of sensitive properties for launchProperties.
        """
        if properties is not None:
            pulumi.set(__self__, "properties", properties)
        if secrets is not None:
            pulumi.set(__self__, "secrets", secrets)

    @property
    @pulumi.getter
    def properties(self) -> Optional[Mapping[str, str]]:
        """
        Specifies a map of non-sensitive properties for launchProperties.
        """
        return pulumi.get(self, "properties")

    @property
    @pulumi.getter
    def secrets(self) -> Optional[Mapping[str, str]]:
        """
        Specifies a map of sensitive properties for launchProperties.
        """
        return pulumi.get(self, "secrets")


@pulumi.output_type
class SpringCloudBuilderBuildPackGroup(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "buildPackIds":
            suggest = "build_pack_ids"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpringCloudBuilderBuildPackGroup. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpringCloudBuilderBuildPackGroup.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpringCloudBuilderBuildPackGroup.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 build_pack_ids: Optional[Sequence[str]] = None):
        """
        :param str name: The name which should be used for this build pack group.
        :param Sequence[str] build_pack_ids: Specifies a list of the build pack's ID.
        """
        pulumi.set(__self__, "name", name)
        if build_pack_ids is not None:
            pulumi.set(__self__, "build_pack_ids", build_pack_ids)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name which should be used for this build pack group.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="buildPackIds")
    def build_pack_ids(self) -> Optional[Sequence[str]]:
        """
        Specifies a list of the build pack's ID.
        """
        return pulumi.get(self, "build_pack_ids")


@pulumi.output_type
class SpringCloudBuilderStack(dict):
    def __init__(__self__, *,
                 id: str,
                 version: str):
        """
        :param str id: Specifies the ID of the ClusterStack.
        :param str version: Specifies the version of the ClusterStack
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        Specifies the ID of the ClusterStack.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def version(self) -> str:
        """
        Specifies the version of the ClusterStack
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class SpringCloudConfigurationServiceRepository(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hostKey":
            suggest = "host_key"
        elif key == "hostKeyAlgorithm":
            suggest = "host_key_algorithm"
        elif key == "privateKey":
            suggest = "private_key"
        elif key == "searchPaths":
            suggest = "search_paths"
        elif key == "strictHostKeyChecking":
            suggest = "strict_host_key_checking"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpringCloudConfigurationServiceRepository. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpringCloudConfigurationServiceRepository.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpringCloudConfigurationServiceRepository.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 label: str,
                 name: str,
                 patterns: Sequence[str],
                 uri: str,
                 host_key: Optional[str] = None,
                 host_key_algorithm: Optional[str] = None,
                 password: Optional[str] = None,
                 private_key: Optional[str] = None,
                 search_paths: Optional[Sequence[str]] = None,
                 strict_host_key_checking: Optional[bool] = None,
                 username: Optional[str] = None):
        """
        :param str label: Specifies the label of the repository.
        :param str name: Specifies the name which should be used for this repository.
        :param Sequence[str] patterns: Specifies the collection of patterns of the repository.
        :param str uri: Specifies the URI of the repository.
        :param str host_key: Specifies the SSH public key of git repository.
        :param str host_key_algorithm: Specifies the SSH key algorithm of git repository.
        :param str password: Specifies the password of git repository basic auth.
        :param str private_key: Specifies the SSH private key of git repository.
        :param Sequence[str] search_paths: Specifies a list of searching path of the repository
        :param bool strict_host_key_checking: Specifies whether enable the strict host key checking.
        :param str username: Specifies the username of git repository basic auth.
        """
        pulumi.set(__self__, "label", label)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "patterns", patterns)
        pulumi.set(__self__, "uri", uri)
        if host_key is not None:
            pulumi.set(__self__, "host_key", host_key)
        if host_key_algorithm is not None:
            pulumi.set(__self__, "host_key_algorithm", host_key_algorithm)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if private_key is not None:
            pulumi.set(__self__, "private_key", private_key)
        if search_paths is not None:
            pulumi.set(__self__, "search_paths", search_paths)
        if strict_host_key_checking is not None:
            pulumi.set(__self__, "strict_host_key_checking", strict_host_key_checking)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def label(self) -> str:
        """
        Specifies the label of the repository.
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the name which should be used for this repository.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def patterns(self) -> Sequence[str]:
        """
        Specifies the collection of patterns of the repository.
        """
        return pulumi.get(self, "patterns")

    @property
    @pulumi.getter
    def uri(self) -> str:
        """
        Specifies the URI of the repository.
        """
        return pulumi.get(self, "uri")

    @property
    @pulumi.getter(name="hostKey")
    def host_key(self) -> Optional[str]:
        """
        Specifies the SSH public key of git repository.
        """
        return pulumi.get(self, "host_key")

    @property
    @pulumi.getter(name="hostKeyAlgorithm")
    def host_key_algorithm(self) -> Optional[str]:
        """
        Specifies the SSH key algorithm of git repository.
        """
        return pulumi.get(self, "host_key_algorithm")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        Specifies the password of git repository basic auth.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="privateKey")
    def private_key(self) -> Optional[str]:
        """
        Specifies the SSH private key of git repository.
        """
        return pulumi.get(self, "private_key")

    @property
    @pulumi.getter(name="searchPaths")
    def search_paths(self) -> Optional[Sequence[str]]:
        """
        Specifies a list of searching path of the repository
        """
        return pulumi.get(self, "search_paths")

    @property
    @pulumi.getter(name="strictHostKeyChecking")
    def strict_host_key_checking(self) -> Optional[bool]:
        """
        Specifies whether enable the strict host key checking.
        """
        return pulumi.get(self, "strict_host_key_checking")

    @property
    @pulumi.getter
    def username(self) -> Optional[str]:
        """
        Specifies the username of git repository basic auth.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class SpringCloudContainerDeploymentQuota(dict):
    def __init__(__self__, *,
                 cpu: Optional[str] = None,
                 memory: Optional[str] = None):
        """
        :param str cpu: Specifies the required cpu of the Spring Cloud Deployment. Possible Values are `500m`, `1`, `2`, `3` and `4`. Defaults to `1` if not specified.
        :param str memory: Specifies the required memory size of the Spring Cloud Deployment. Possible Values are `512Mi`, `1Gi`, `2Gi`, `3Gi`, `4Gi`, `5Gi`, `6Gi`, `7Gi`, and `8Gi`. Defaults to `1Gi` if not specified.
        """
        if cpu is not None:
            pulumi.set(__self__, "cpu", cpu)
        if memory is not None:
            pulumi.set(__self__, "memory", memory)

    @property
    @pulumi.getter
    def cpu(self) -> Optional[str]:
        """
        Specifies the required cpu of the Spring Cloud Deployment. Possible Values are `500m`, `1`, `2`, `3` and `4`. Defaults to `1` if not specified.
        """
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter
    def memory(self) -> Optional[str]:
        """
        Specifies the required memory size of the Spring Cloud Deployment. Possible Values are `512Mi`, `1Gi`, `2Gi`, `3Gi`, `4Gi`, `5Gi`, `6Gi`, `7Gi`, and `8Gi`. Defaults to `1Gi` if not specified.
        """
        return pulumi.get(self, "memory")


@pulumi.output_type
class SpringCloudGatewayApiMetadata(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "documentationUrl":
            suggest = "documentation_url"
        elif key == "serverUrl":
            suggest = "server_url"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpringCloudGatewayApiMetadata. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpringCloudGatewayApiMetadata.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpringCloudGatewayApiMetadata.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 description: Optional[str] = None,
                 documentation_url: Optional[str] = None,
                 server_url: Optional[str] = None,
                 title: Optional[str] = None,
                 version: Optional[str] = None):
        """
        :param str description: Detailed description of the APIs available on the Gateway instance.
        :param str documentation_url: Location of additional documentation for the APIs available on the Gateway instance.
        :param str server_url: Base URL that API consumers will use to access APIs on the Gateway instance.
        :param str title: Specifies the title describing the context of the APIs available on the Gateway instance.
        :param str version: Specifies the version of APIs available on this Gateway instance.
        """
        if description is not None:
            pulumi.set(__self__, "description", description)
        if documentation_url is not None:
            pulumi.set(__self__, "documentation_url", documentation_url)
        if server_url is not None:
            pulumi.set(__self__, "server_url", server_url)
        if title is not None:
            pulumi.set(__self__, "title", title)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        Detailed description of the APIs available on the Gateway instance.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="documentationUrl")
    def documentation_url(self) -> Optional[str]:
        """
        Location of additional documentation for the APIs available on the Gateway instance.
        """
        return pulumi.get(self, "documentation_url")

    @property
    @pulumi.getter(name="serverUrl")
    def server_url(self) -> Optional[str]:
        """
        Base URL that API consumers will use to access APIs on the Gateway instance.
        """
        return pulumi.get(self, "server_url")

    @property
    @pulumi.getter
    def title(self) -> Optional[str]:
        """
        Specifies the title describing the context of the APIs available on the Gateway instance.
        """
        return pulumi.get(self, "title")

    @property
    @pulumi.getter
    def version(self) -> Optional[str]:
        """
        Specifies the version of APIs available on this Gateway instance.
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class SpringCloudGatewayCors(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedHeaders":
            suggest = "allowed_headers"
        elif key == "allowedMethods":
            suggest = "allowed_methods"
        elif key == "allowedOrigins":
            suggest = "allowed_origins"
        elif key == "credentialsAllowed":
            suggest = "credentials_allowed"
        elif key == "exposedHeaders":
            suggest = "exposed_headers"
        elif key == "maxAgeSeconds":
            suggest = "max_age_seconds"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpringCloudGatewayCors. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpringCloudGatewayCors.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpringCloudGatewayCors.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 allowed_headers: Optional[Sequence[str]] = None,
                 allowed_methods: Optional[Sequence[str]] = None,
                 allowed_origins: Optional[Sequence[str]] = None,
                 credentials_allowed: Optional[bool] = None,
                 exposed_headers: Optional[Sequence[str]] = None,
                 max_age_seconds: Optional[int] = None):
        """
        :param Sequence[str] allowed_headers: Allowed headers in cross-site requests. The special value `*` allows actual requests to send any header.
        :param Sequence[str] allowed_methods: Allowed HTTP methods on cross-site requests. The special value `*` allows all methods. If not set, `GET` and `HEAD` are allowed by default.
        :param Sequence[str] allowed_origins: Allowed origins to make cross-site requests. The special value `*` allows all domains.
        :param bool credentials_allowed: is user credentials are supported on cross-site requests?
        :param Sequence[str] exposed_headers: HTTP response headers to expose for cross-site requests.
        :param int max_age_seconds: How long, in seconds, the response from a pre-flight request can be cached by clients.
        """
        if allowed_headers is not None:
            pulumi.set(__self__, "allowed_headers", allowed_headers)
        if allowed_methods is not None:
            pulumi.set(__self__, "allowed_methods", allowed_methods)
        if allowed_origins is not None:
            pulumi.set(__self__, "allowed_origins", allowed_origins)
        if credentials_allowed is not None:
            pulumi.set(__self__, "credentials_allowed", credentials_allowed)
        if exposed_headers is not None:
            pulumi.set(__self__, "exposed_headers", exposed_headers)
        if max_age_seconds is not None:
            pulumi.set(__self__, "max_age_seconds", max_age_seconds)

    @property
    @pulumi.getter(name="allowedHeaders")
    def allowed_headers(self) -> Optional[Sequence[str]]:
        """
        Allowed headers in cross-site requests. The special value `*` allows actual requests to send any header.
        """
        return pulumi.get(self, "allowed_headers")

    @property
    @pulumi.getter(name="allowedMethods")
    def allowed_methods(self) -> Optional[Sequence[str]]:
        """
        Allowed HTTP methods on cross-site requests. The special value `*` allows all methods. If not set, `GET` and `HEAD` are allowed by default.
        """
        return pulumi.get(self, "allowed_methods")

    @property
    @pulumi.getter(name="allowedOrigins")
    def allowed_origins(self) -> Optional[Sequence[str]]:
        """
        Allowed origins to make cross-site requests. The special value `*` allows all domains.
        """
        return pulumi.get(self, "allowed_origins")

    @property
    @pulumi.getter(name="credentialsAllowed")
    def credentials_allowed(self) -> Optional[bool]:
        """
        is user credentials are supported on cross-site requests?
        """
        return pulumi.get(self, "credentials_allowed")

    @property
    @pulumi.getter(name="exposedHeaders")
    def exposed_headers(self) -> Optional[Sequence[str]]:
        """
        HTTP response headers to expose for cross-site requests.
        """
        return pulumi.get(self, "exposed_headers")

    @property
    @pulumi.getter(name="maxAgeSeconds")
    def max_age_seconds(self) -> Optional[int]:
        """
        How long, in seconds, the response from a pre-flight request can be cached by clients.
        """
        return pulumi.get(self, "max_age_seconds")


@pulumi.output_type
class SpringCloudGatewayQuota(dict):
    def __init__(__self__, *,
                 cpu: Optional[str] = None,
                 memory: Optional[str] = None):
        """
        :param str cpu: Specifies the required cpu of the Spring Cloud Deployment. Possible Values are `500m`, `1`, `2`, `3` and `4`. Defaults to `1` if not specified.
        :param str memory: Specifies the required memory size of the Spring Cloud Deployment. Possible Values are `512Mi`, `1Gi`, `2Gi`, `3Gi`, `4Gi`, `5Gi`, `6Gi`, `7Gi`, and `8Gi`. Defaults to `1Gi` if not specified.
        """
        if cpu is not None:
            pulumi.set(__self__, "cpu", cpu)
        if memory is not None:
            pulumi.set(__self__, "memory", memory)

    @property
    @pulumi.getter
    def cpu(self) -> Optional[str]:
        """
        Specifies the required cpu of the Spring Cloud Deployment. Possible Values are `500m`, `1`, `2`, `3` and `4`. Defaults to `1` if not specified.
        """
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter
    def memory(self) -> Optional[str]:
        """
        Specifies the required memory size of the Spring Cloud Deployment. Possible Values are `512Mi`, `1Gi`, `2Gi`, `3Gi`, `4Gi`, `5Gi`, `6Gi`, `7Gi`, and `8Gi`. Defaults to `1Gi` if not specified.
        """
        return pulumi.get(self, "memory")


@pulumi.output_type
class SpringCloudGatewayRouteConfigRoute(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "classificationTags":
            suggest = "classification_tags"
        elif key == "ssoValidationEnabled":
            suggest = "sso_validation_enabled"
        elif key == "tokenRelay":
            suggest = "token_relay"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpringCloudGatewayRouteConfigRoute. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpringCloudGatewayRouteConfigRoute.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpringCloudGatewayRouteConfigRoute.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 classification_tags: Optional[Sequence[str]] = None,
                 description: Optional[str] = None,
                 filters: Optional[Sequence[str]] = None,
                 order: Optional[int] = None,
                 predicates: Optional[Sequence[str]] = None,
                 sso_validation_enabled: Optional[bool] = None,
                 title: Optional[str] = None,
                 token_relay: Optional[bool] = None,
                 uri: Optional[str] = None):
        """
        :param Sequence[str] classification_tags: Specifies the classification tags which will be applied to methods in the generated OpenAPI documentation.
        :param str description: Specifies the description which will be applied to methods in the generated OpenAPI documentation.
        :param Sequence[str] filters: Specifies a list of filters which are used to modify the request before sending it to the target endpoint, or the received response.
        :param int order: Specifies the route processing order.
        :param Sequence[str] predicates: Specifies a list of conditions to evaluate a route for each request. Each predicate may be evaluated against request headers and parameter values. All of the predicates associated with a route must evaluate to true for the route to be matched to the request.
        :param bool sso_validation_enabled: Should the sso validation be enabled?
        :param str title: Specifies the title which will be applied to methods in the generated OpenAPI documentation.
        :param bool token_relay: Should pass currently-authenticated user's identity token to application service?
        :param str uri: Specifies the full uri which will override `appName`.
        """
        if classification_tags is not None:
            pulumi.set(__self__, "classification_tags", classification_tags)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if filters is not None:
            pulumi.set(__self__, "filters", filters)
        if order is not None:
            pulumi.set(__self__, "order", order)
        if predicates is not None:
            pulumi.set(__self__, "predicates", predicates)
        if sso_validation_enabled is not None:
            pulumi.set(__self__, "sso_validation_enabled", sso_validation_enabled)
        if title is not None:
            pulumi.set(__self__, "title", title)
        if token_relay is not None:
            pulumi.set(__self__, "token_relay", token_relay)
        if uri is not None:
            pulumi.set(__self__, "uri", uri)

    @property
    @pulumi.getter(name="classificationTags")
    def classification_tags(self) -> Optional[Sequence[str]]:
        """
        Specifies the classification tags which will be applied to methods in the generated OpenAPI documentation.
        """
        return pulumi.get(self, "classification_tags")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        Specifies the description which will be applied to methods in the generated OpenAPI documentation.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def filters(self) -> Optional[Sequence[str]]:
        """
        Specifies a list of filters which are used to modify the request before sending it to the target endpoint, or the received response.
        """
        return pulumi.get(self, "filters")

    @property
    @pulumi.getter
    def order(self) -> Optional[int]:
        """
        Specifies the route processing order.
        """
        return pulumi.get(self, "order")

    @property
    @pulumi.getter
    def predicates(self) -> Optional[Sequence[str]]:
        """
        Specifies a list of conditions to evaluate a route for each request. Each predicate may be evaluated against request headers and parameter values. All of the predicates associated with a route must evaluate to true for the route to be matched to the request.
        """
        return pulumi.get(self, "predicates")

    @property
    @pulumi.getter(name="ssoValidationEnabled")
    def sso_validation_enabled(self) -> Optional[bool]:
        """
        Should the sso validation be enabled?
        """
        return pulumi.get(self, "sso_validation_enabled")

    @property
    @pulumi.getter
    def title(self) -> Optional[str]:
        """
        Specifies the title which will be applied to methods in the generated OpenAPI documentation.
        """
        return pulumi.get(self, "title")

    @property
    @pulumi.getter(name="tokenRelay")
    def token_relay(self) -> Optional[bool]:
        """
        Should pass currently-authenticated user's identity token to application service?
        """
        return pulumi.get(self, "token_relay")

    @property
    @pulumi.getter
    def uri(self) -> Optional[str]:
        """
        Specifies the full uri which will override `appName`.
        """
        return pulumi.get(self, "uri")


@pulumi.output_type
class SpringCloudGatewaySso(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientId":
            suggest = "client_id"
        elif key == "clientSecret":
            suggest = "client_secret"
        elif key == "issuerUri":
            suggest = "issuer_uri"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpringCloudGatewaySso. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpringCloudGatewaySso.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpringCloudGatewaySso.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 client_id: Optional[str] = None,
                 client_secret: Optional[str] = None,
                 issuer_uri: Optional[str] = None,
                 scopes: Optional[Sequence[str]] = None):
        """
        :param str client_id: The public identifier for the application.
        :param str client_secret: The secret known only to the application and the authorization server.
        :param str issuer_uri: The URI of Issuer Identifier.
        :param Sequence[str] scopes: It defines the specific actions applications can be allowed to do on a user's behalf.
        """
        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 issuer_uri is not None:
            pulumi.set(__self__, "issuer_uri", issuer_uri)
        if scopes is not None:
            pulumi.set(__self__, "scopes", scopes)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> Optional[str]:
        """
        The public identifier for the application.
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> Optional[str]:
        """
        The secret known only to the application and the authorization server.
        """
        return pulumi.get(self, "client_secret")

    @property
    @pulumi.getter(name="issuerUri")
    def issuer_uri(self) -> Optional[str]:
        """
        The URI of Issuer Identifier.
        """
        return pulumi.get(self, "issuer_uri")

    @property
    @pulumi.getter
    def scopes(self) -> Optional[Sequence[str]]:
        """
        It defines the specific actions applications can be allowed to do on a user's behalf.
        """
        return pulumi.get(self, "scopes")


@pulumi.output_type
class SpringCloudJavaDeploymentQuota(dict):
    def __init__(__self__, *,
                 cpu: Optional[str] = None,
                 memory: Optional[str] = None):
        """
        :param str cpu: Specifies the required cpu of the Spring Cloud Deployment. Possible Values are `500m`, `1`, `2`, `3` and `4`. Defaults to `1` if not specified.
        :param str memory: Specifies the required memory size of the Spring Cloud Deployment. Possible Values are `512Mi`, `1Gi`, `2Gi`, `3Gi`, `4Gi`, `5Gi`, `6Gi`, `7Gi`, and `8Gi`. Defaults to `1Gi` if not specified.
        """
        if cpu is not None:
            pulumi.set(__self__, "cpu", cpu)
        if memory is not None:
            pulumi.set(__self__, "memory", memory)

    @property
    @pulumi.getter
    def cpu(self) -> Optional[str]:
        """
        Specifies the required cpu of the Spring Cloud Deployment. Possible Values are `500m`, `1`, `2`, `3` and `4`. Defaults to `1` if not specified.
        """
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter
    def memory(self) -> Optional[str]:
        """
        Specifies the required memory size of the Spring Cloud Deployment. Possible Values are `512Mi`, `1Gi`, `2Gi`, `3Gi`, `4Gi`, `5Gi`, `6Gi`, `7Gi`, and `8Gi`. Defaults to `1Gi` if not specified.
        """
        return pulumi.get(self, "memory")


@pulumi.output_type
class SpringCloudServiceConfigServerGitSetting(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "httpBasicAuth":
            suggest = "http_basic_auth"
        elif key == "searchPaths":
            suggest = "search_paths"
        elif key == "sshAuth":
            suggest = "ssh_auth"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpringCloudServiceConfigServerGitSetting. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpringCloudServiceConfigServerGitSetting.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpringCloudServiceConfigServerGitSetting.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 uri: str,
                 http_basic_auth: Optional['outputs.SpringCloudServiceConfigServerGitSettingHttpBasicAuth'] = None,
                 label: Optional[str] = None,
                 repositories: Optional[Sequence['outputs.SpringCloudServiceConfigServerGitSettingRepository']] = None,
                 search_paths: Optional[Sequence[str]] = None,
                 ssh_auth: Optional['outputs.SpringCloudServiceConfigServerGitSettingSshAuth'] = None):
        """
        :param str uri: The URI of the default Git repository used as the Config Server back end, should be started with `http://`, `https://`, `git@`, or `ssh://`.
        :param 'SpringCloudServiceConfigServerGitSettingHttpBasicAuthArgs' http_basic_auth: A `http_basic_auth` block as defined below.
        :param str label: The default label of the Git repository, should be the branch name, tag name, or commit-id of the repository.
        :param Sequence['SpringCloudServiceConfigServerGitSettingRepositoryArgs'] repositories: One or more `repository` blocks as defined below.
        :param Sequence[str] search_paths: An array of strings used to search subdirectories of the Git repository.
        :param 'SpringCloudServiceConfigServerGitSettingSshAuthArgs' ssh_auth: A `ssh_auth` block as defined below.
        """
        pulumi.set(__self__, "uri", uri)
        if http_basic_auth is not None:
            pulumi.set(__self__, "http_basic_auth", http_basic_auth)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if repositories is not None:
            pulumi.set(__self__, "repositories", repositories)
        if search_paths is not None:
            pulumi.set(__self__, "search_paths", search_paths)
        if ssh_auth is not None:
            pulumi.set(__self__, "ssh_auth", ssh_auth)

    @property
    @pulumi.getter
    def uri(self) -> str:
        """
        The URI of the default Git repository used as the Config Server back end, should be started with `http://`, `https://`, `git@`, or `ssh://`.
        """
        return pulumi.get(self, "uri")

    @property
    @pulumi.getter(name="httpBasicAuth")
    def http_basic_auth(self) -> Optional['outputs.SpringCloudServiceConfigServerGitSettingHttpBasicAuth']:
        """
        A `http_basic_auth` block as defined below.
        """
        return pulumi.get(self, "http_basic_auth")

    @property
    @pulumi.getter
    def label(self) -> Optional[str]:
        """
        The default label of the Git repository, should be the branch name, tag name, or commit-id of the repository.
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter
    def repositories(self) -> Optional[Sequence['outputs.SpringCloudServiceConfigServerGitSettingRepository']]:
        """
        One or more `repository` blocks as defined below.
        """
        return pulumi.get(self, "repositories")

    @property
    @pulumi.getter(name="searchPaths")
    def search_paths(self) -> Optional[Sequence[str]]:
        """
        An array of strings used to search subdirectories of the Git repository.
        """
        return pulumi.get(self, "search_paths")

    @property
    @pulumi.getter(name="sshAuth")
    def ssh_auth(self) -> Optional['outputs.SpringCloudServiceConfigServerGitSettingSshAuth']:
        """
        A `ssh_auth` block as defined below.
        """
        return pulumi.get(self, "ssh_auth")


@pulumi.output_type
class SpringCloudServiceConfigServerGitSettingHttpBasicAuth(dict):
    def __init__(__self__, *,
                 password: str,
                 username: str):
        """
        :param str password: The password used to access the Git repository server, required when the Git repository server supports HTTP Basic Authentication.
        :param str username: The username that's used to access the Git repository server, required when the Git repository server supports HTTP Basic Authentication.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The password used to access the Git repository server, required when the Git repository server supports HTTP Basic Authentication.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The username that's used to access the Git repository server, required when the Git repository server supports HTTP Basic Authentication.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class SpringCloudServiceConfigServerGitSettingRepository(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "httpBasicAuth":
            suggest = "http_basic_auth"
        elif key == "searchPaths":
            suggest = "search_paths"
        elif key == "sshAuth":
            suggest = "ssh_auth"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpringCloudServiceConfigServerGitSettingRepository. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpringCloudServiceConfigServerGitSettingRepository.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpringCloudServiceConfigServerGitSettingRepository.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 uri: str,
                 http_basic_auth: Optional['outputs.SpringCloudServiceConfigServerGitSettingRepositoryHttpBasicAuth'] = None,
                 label: Optional[str] = None,
                 patterns: Optional[Sequence[str]] = None,
                 search_paths: Optional[Sequence[str]] = None,
                 ssh_auth: Optional['outputs.SpringCloudServiceConfigServerGitSettingRepositorySshAuth'] = None):
        """
        :param str name: A name to identify on the Git repository, required only if repos exists.
        :param str uri: The URI of the Git repository that's used as the Config Server back end should be started with `http://`, `https://`, `git@`, or `ssh://`.
        :param 'SpringCloudServiceConfigServerGitSettingRepositoryHttpBasicAuthArgs' http_basic_auth: A `http_basic_auth` block as defined below.
        :param str label: The default label of the Git repository, should be the branch name, tag name, or commit-id of the repository.
        :param Sequence[str] patterns: An array of strings used to match an application name. For each pattern, use the `{application}/{profile}` format with wildcards.
        :param Sequence[str] search_paths: An array of strings used to search subdirectories of the Git repository.
        :param 'SpringCloudServiceConfigServerGitSettingRepositorySshAuthArgs' ssh_auth: A `ssh_auth` block as defined below.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "uri", uri)
        if http_basic_auth is not None:
            pulumi.set(__self__, "http_basic_auth", http_basic_auth)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if patterns is not None:
            pulumi.set(__self__, "patterns", patterns)
        if search_paths is not None:
            pulumi.set(__self__, "search_paths", search_paths)
        if ssh_auth is not None:
            pulumi.set(__self__, "ssh_auth", ssh_auth)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        A name to identify on the Git repository, required only if repos exists.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def uri(self) -> str:
        """
        The URI of the Git repository that's used as the Config Server back end should be started with `http://`, `https://`, `git@`, or `ssh://`.
        """
        return pulumi.get(self, "uri")

    @property
    @pulumi.getter(name="httpBasicAuth")
    def http_basic_auth(self) -> Optional['outputs.SpringCloudServiceConfigServerGitSettingRepositoryHttpBasicAuth']:
        """
        A `http_basic_auth` block as defined below.
        """
        return pulumi.get(self, "http_basic_auth")

    @property
    @pulumi.getter
    def label(self) -> Optional[str]:
        """
        The default label of the Git repository, should be the branch name, tag name, or commit-id of the repository.
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter
    def patterns(self) -> Optional[Sequence[str]]:
        """
        An array of strings used to match an application name. For each pattern, use the `{application}/{profile}` format with wildcards.
        """
        return pulumi.get(self, "patterns")

    @property
    @pulumi.getter(name="searchPaths")
    def search_paths(self) -> Optional[Sequence[str]]:
        """
        An array of strings used to search subdirectories of the Git repository.
        """
        return pulumi.get(self, "search_paths")

    @property
    @pulumi.getter(name="sshAuth")
    def ssh_auth(self) -> Optional['outputs.SpringCloudServiceConfigServerGitSettingRepositorySshAuth']:
        """
        A `ssh_auth` block as defined below.
        """
        return pulumi.get(self, "ssh_auth")


@pulumi.output_type
class SpringCloudServiceConfigServerGitSettingRepositoryHttpBasicAuth(dict):
    def __init__(__self__, *,
                 password: str,
                 username: str):
        """
        :param str password: The password used to access the Git repository server, required when the Git repository server supports HTTP Basic Authentication.
        :param str username: The username that's used to access the Git repository server, required when the Git repository server supports HTTP Basic Authentication.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The password used to access the Git repository server, required when the Git repository server supports HTTP Basic Authentication.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The username that's used to access the Git repository server, required when the Git repository server supports HTTP Basic Authentication.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class SpringCloudServiceConfigServerGitSettingRepositorySshAuth(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "privateKey":
            suggest = "private_key"
        elif key == "hostKey":
            suggest = "host_key"
        elif key == "hostKeyAlgorithm":
            suggest = "host_key_algorithm"
        elif key == "strictHostKeyCheckingEnabled":
            suggest = "strict_host_key_checking_enabled"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpringCloudServiceConfigServerGitSettingRepositorySshAuth. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpringCloudServiceConfigServerGitSettingRepositorySshAuth.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpringCloudServiceConfigServerGitSettingRepositorySshAuth.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 private_key: str,
                 host_key: Optional[str] = None,
                 host_key_algorithm: Optional[str] = None,
                 strict_host_key_checking_enabled: Optional[bool] = None):
        """
        :param str private_key: The SSH private key to access the Git repository, required when the URI starts with `git@` or `ssh://`.
        :param str host_key: The host key of the Git repository server, should not include the algorithm prefix as covered by `host-key-algorithm`.
        :param str host_key_algorithm: The host key algorithm, should be `ssh-dss`, `ssh-rsa`, `ecdsa-sha2-nistp256`, `ecdsa-sha2-nistp384`, or `ecdsa-sha2-nistp521`. Required only if `host-key` exists.
        :param bool strict_host_key_checking_enabled: Indicates whether the Config Server instance will fail to start if the host_key does not match.
        """
        pulumi.set(__self__, "private_key", private_key)
        if host_key is not None:
            pulumi.set(__self__, "host_key", host_key)
        if host_key_algorithm is not None:
            pulumi.set(__self__, "host_key_algorithm", host_key_algorithm)
        if strict_host_key_checking_enabled is not None:
            pulumi.set(__self__, "strict_host_key_checking_enabled", strict_host_key_checking_enabled)

    @property
    @pulumi.getter(name="privateKey")
    def private_key(self) -> str:
        """
        The SSH private key to access the Git repository, required when the URI starts with `git@` or `ssh://`.
        """
        return pulumi.get(self, "private_key")

    @property
    @pulumi.getter(name="hostKey")
    def host_key(self) -> Optional[str]:
        """
        The host key of the Git repository server, should not include the algorithm prefix as covered by `host-key-algorithm`.
        """
        return pulumi.get(self, "host_key")

    @property
    @pulumi.getter(name="hostKeyAlgorithm")
    def host_key_algorithm(self) -> Optional[str]:
        """
        The host key algorithm, should be `ssh-dss`, `ssh-rsa`, `ecdsa-sha2-nistp256`, `ecdsa-sha2-nistp384`, or `ecdsa-sha2-nistp521`. Required only if `host-key` exists.
        """
        return pulumi.get(self, "host_key_algorithm")

    @property
    @pulumi.getter(name="strictHostKeyCheckingEnabled")
    def strict_host_key_checking_enabled(self) -> Optional[bool]:
        """
        Indicates whether the Config Server instance will fail to start if the host_key does not match.
        """
        return pulumi.get(self, "strict_host_key_checking_enabled")


@pulumi.output_type
class SpringCloudServiceConfigServerGitSettingSshAuth(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "privateKey":
            suggest = "private_key"
        elif key == "hostKey":
            suggest = "host_key"
        elif key == "hostKeyAlgorithm":
            suggest = "host_key_algorithm"
        elif key == "strictHostKeyCheckingEnabled":
            suggest = "strict_host_key_checking_enabled"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpringCloudServiceConfigServerGitSettingSshAuth. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpringCloudServiceConfigServerGitSettingSshAuth.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpringCloudServiceConfigServerGitSettingSshAuth.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 private_key: str,
                 host_key: Optional[str] = None,
                 host_key_algorithm: Optional[str] = None,
                 strict_host_key_checking_enabled: Optional[bool] = None):
        """
        :param str private_key: The SSH private key to access the Git repository, required when the URI starts with `git@` or `ssh://`.
        :param str host_key: The host key of the Git repository server, should not include the algorithm prefix as covered by `host-key-algorithm`.
        :param str host_key_algorithm: The host key algorithm, should be `ssh-dss`, `ssh-rsa`, `ecdsa-sha2-nistp256`, `ecdsa-sha2-nistp384`, or `ecdsa-sha2-nistp521`. Required only if `host-key` exists.
        :param bool strict_host_key_checking_enabled: Indicates whether the Config Server instance will fail to start if the host_key does not match.
        """
        pulumi.set(__self__, "private_key", private_key)
        if host_key is not None:
            pulumi.set(__self__, "host_key", host_key)
        if host_key_algorithm is not None:
            pulumi.set(__self__, "host_key_algorithm", host_key_algorithm)
        if strict_host_key_checking_enabled is not None:
            pulumi.set(__self__, "strict_host_key_checking_enabled", strict_host_key_checking_enabled)

    @property
    @pulumi.getter(name="privateKey")
    def private_key(self) -> str:
        """
        The SSH private key to access the Git repository, required when the URI starts with `git@` or `ssh://`.
        """
        return pulumi.get(self, "private_key")

    @property
    @pulumi.getter(name="hostKey")
    def host_key(self) -> Optional[str]:
        """
        The host key of the Git repository server, should not include the algorithm prefix as covered by `host-key-algorithm`.
        """
        return pulumi.get(self, "host_key")

    @property
    @pulumi.getter(name="hostKeyAlgorithm")
    def host_key_algorithm(self) -> Optional[str]:
        """
        The host key algorithm, should be `ssh-dss`, `ssh-rsa`, `ecdsa-sha2-nistp256`, `ecdsa-sha2-nistp384`, or `ecdsa-sha2-nistp521`. Required only if `host-key` exists.
        """
        return pulumi.get(self, "host_key_algorithm")

    @property
    @pulumi.getter(name="strictHostKeyCheckingEnabled")
    def strict_host_key_checking_enabled(self) -> Optional[bool]:
        """
        Indicates whether the Config Server instance will fail to start if the host_key does not match.
        """
        return pulumi.get(self, "strict_host_key_checking_enabled")


@pulumi.output_type
class SpringCloudServiceNetwork(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "appSubnetId":
            suggest = "app_subnet_id"
        elif key == "cidrRanges":
            suggest = "cidr_ranges"
        elif key == "serviceRuntimeSubnetId":
            suggest = "service_runtime_subnet_id"
        elif key == "appNetworkResourceGroup":
            suggest = "app_network_resource_group"
        elif key == "serviceRuntimeNetworkResourceGroup":
            suggest = "service_runtime_network_resource_group"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpringCloudServiceNetwork. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpringCloudServiceNetwork.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpringCloudServiceNetwork.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 app_subnet_id: str,
                 cidr_ranges: Sequence[str],
                 service_runtime_subnet_id: str,
                 app_network_resource_group: Optional[str] = None,
                 service_runtime_network_resource_group: Optional[str] = None):
        """
        :param str app_subnet_id: Specifies the ID of the Subnet which should host the Spring Boot Applications deployed in this Spring Cloud Service. Changing this forces a new resource to be created.
        :param Sequence[str] cidr_ranges: A list of (at least 3) CIDR ranges (at least /16) which are used to host the Spring Cloud infrastructure, which must not overlap with any existing CIDR ranges in the Subnet. Changing this forces a new resource to be created.
        :param str service_runtime_subnet_id: Specifies the ID of the Subnet where the Service Runtime components of the Spring Cloud Service will exist. Changing this forces a new resource to be created.
        :param str app_network_resource_group: Specifies the Name of the resource group containing network resources of Azure Spring Cloud Apps. Changing this forces a new resource to be created.
        :param str service_runtime_network_resource_group: Specifies the Name of the resource group containing network resources of Azure Spring Cloud Service Runtime. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "app_subnet_id", app_subnet_id)
        pulumi.set(__self__, "cidr_ranges", cidr_ranges)
        pulumi.set(__self__, "service_runtime_subnet_id", service_runtime_subnet_id)
        if app_network_resource_group is not None:
            pulumi.set(__self__, "app_network_resource_group", app_network_resource_group)
        if service_runtime_network_resource_group is not None:
            pulumi.set(__self__, "service_runtime_network_resource_group", service_runtime_network_resource_group)

    @property
    @pulumi.getter(name="appSubnetId")
    def app_subnet_id(self) -> str:
        """
        Specifies the ID of the Subnet which should host the Spring Boot Applications deployed in this Spring Cloud Service. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "app_subnet_id")

    @property
    @pulumi.getter(name="cidrRanges")
    def cidr_ranges(self) -> Sequence[str]:
        """
        A list of (at least 3) CIDR ranges (at least /16) which are used to host the Spring Cloud infrastructure, which must not overlap with any existing CIDR ranges in the Subnet. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "cidr_ranges")

    @property
    @pulumi.getter(name="serviceRuntimeSubnetId")
    def service_runtime_subnet_id(self) -> str:
        """
        Specifies the ID of the Subnet where the Service Runtime components of the Spring Cloud Service will exist. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "service_runtime_subnet_id")

    @property
    @pulumi.getter(name="appNetworkResourceGroup")
    def app_network_resource_group(self) -> Optional[str]:
        """
        Specifies the Name of the resource group containing network resources of Azure Spring Cloud Apps. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "app_network_resource_group")

    @property
    @pulumi.getter(name="serviceRuntimeNetworkResourceGroup")
    def service_runtime_network_resource_group(self) -> Optional[str]:
        """
        Specifies the Name of the resource group containing network resources of Azure Spring Cloud Service Runtime. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "service_runtime_network_resource_group")


@pulumi.output_type
class SpringCloudServiceRequiredNetworkTrafficRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipAddresses":
            suggest = "ip_addresses"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpringCloudServiceRequiredNetworkTrafficRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpringCloudServiceRequiredNetworkTrafficRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpringCloudServiceRequiredNetworkTrafficRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 direction: Optional[str] = None,
                 fqdns: Optional[Sequence[str]] = None,
                 ip_addresses: Optional[Sequence[str]] = None,
                 port: Optional[int] = None,
                 protocol: Optional[str] = None):
        """
        :param str direction: The direction of required traffic. Possible values are `Inbound`, `Outbound`.
        :param Sequence[str] fqdns: The FQDN list of required traffic.
        :param int port: The port of required traffic.
        :param str protocol: The protocol of required traffic.
        """
        if direction is not None:
            pulumi.set(__self__, "direction", direction)
        if fqdns is not None:
            pulumi.set(__self__, "fqdns", fqdns)
        if ip_addresses is not None:
            pulumi.set(__self__, "ip_addresses", ip_addresses)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)

    @property
    @pulumi.getter
    def direction(self) -> Optional[str]:
        """
        The direction of required traffic. Possible values are `Inbound`, `Outbound`.
        """
        return pulumi.get(self, "direction")

    @property
    @pulumi.getter
    def fqdns(self) -> Optional[Sequence[str]]:
        """
        The FQDN list of required traffic.
        """
        return pulumi.get(self, "fqdns")

    @property
    @pulumi.getter(name="ipAddresses")
    def ip_addresses(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "ip_addresses")

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        The port of required traffic.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def protocol(self) -> Optional[str]:
        """
        The protocol of required traffic.
        """
        return pulumi.get(self, "protocol")


@pulumi.output_type
class SpringCloudServiceTrace(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "connectionString":
            suggest = "connection_string"
        elif key == "sampleRate":
            suggest = "sample_rate"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SpringCloudServiceTrace. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SpringCloudServiceTrace.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SpringCloudServiceTrace.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 connection_string: Optional[str] = None,
                 sample_rate: Optional[float] = None):
        """
        :param str connection_string: The connection string used for Application Insights.
        :param float sample_rate: The sampling rate of Application Insights Agent. Must be between `0.0` and `100.0`. Defaults to `10.0`.
        """
        if connection_string is not None:
            pulumi.set(__self__, "connection_string", connection_string)
        if sample_rate is not None:
            pulumi.set(__self__, "sample_rate", sample_rate)

    @property
    @pulumi.getter(name="connectionString")
    def connection_string(self) -> Optional[str]:
        """
        The connection string used for Application Insights.
        """
        return pulumi.get(self, "connection_string")

    @property
    @pulumi.getter(name="sampleRate")
    def sample_rate(self) -> Optional[float]:
        """
        The sampling rate of Application Insights Agent. Must be between `0.0` and `100.0`. Defaults to `10.0`.
        """
        return pulumi.get(self, "sample_rate")


@pulumi.output_type
class GetSpringCloudAppIdentityResult(dict):
    def __init__(__self__, *,
                 identity_ids: Sequence[str],
                 principal_id: str,
                 tenant_id: str,
                 type: str):
        """
        :param str principal_id: The Principal ID for the Service Principal associated with the Managed Service Identity of this Spring Cloud Application.
        :param str tenant_id: The Tenant ID for the Service Principal associated with the Managed Service Identity of this Spring Cloud Application.
        :param str type: The Type of Managed Identity assigned to the Spring Cloud Application.
        """
        pulumi.set(__self__, "identity_ids", identity_ids)
        pulumi.set(__self__, "principal_id", principal_id)
        pulumi.set(__self__, "tenant_id", tenant_id)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="identityIds")
    def identity_ids(self) -> Sequence[str]:
        return pulumi.get(self, "identity_ids")

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> str:
        """
        The Principal ID for the Service Principal associated with the Managed Service Identity of this Spring Cloud Application.
        """
        return pulumi.get(self, "principal_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        """
        The Tenant ID for the Service Principal associated with the Managed Service Identity of this Spring Cloud Application.
        """
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The Type of Managed Identity assigned to the Spring Cloud Application.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetSpringCloudAppPersistentDiskResult(dict):
    def __init__(__self__, *,
                 mount_path: str,
                 size_in_gb: int):
        """
        :param str mount_path: The mount path of the persistent disk.
        :param int size_in_gb: The size of the persistent disk in GB.
        """
        pulumi.set(__self__, "mount_path", mount_path)
        pulumi.set(__self__, "size_in_gb", size_in_gb)

    @property
    @pulumi.getter(name="mountPath")
    def mount_path(self) -> str:
        """
        The mount path of the persistent disk.
        """
        return pulumi.get(self, "mount_path")

    @property
    @pulumi.getter(name="sizeInGb")
    def size_in_gb(self) -> int:
        """
        The size of the persistent disk in GB.
        """
        return pulumi.get(self, "size_in_gb")


@pulumi.output_type
class GetSpringCloudServiceConfigServerGitSettingResult(dict):
    def __init__(__self__, *,
                 http_basic_auths: Sequence['outputs.GetSpringCloudServiceConfigServerGitSettingHttpBasicAuthResult'],
                 label: str,
                 repositories: Sequence['outputs.GetSpringCloudServiceConfigServerGitSettingRepositoryResult'],
                 search_paths: Sequence[str],
                 ssh_auths: Sequence['outputs.GetSpringCloudServiceConfigServerGitSettingSshAuthResult'],
                 uri: str):
        """
        :param Sequence['GetSpringCloudServiceConfigServerGitSettingHttpBasicAuthArgs'] http_basic_auths: A `http_basic_auth` block as defined below.
        :param str label: The default label of the Git repository, which is a branch name, tag name, or commit-id of the repository
        :param Sequence['GetSpringCloudServiceConfigServerGitSettingRepositoryArgs'] repositories: One or more `repository` blocks as defined below.
        :param Sequence[str] search_paths: An array of strings used to search subdirectories of the Git repository.
        :param Sequence['GetSpringCloudServiceConfigServerGitSettingSshAuthArgs'] ssh_auths: A `ssh_auth` block as defined below.
        :param str uri: The URI of the Git repository
        """
        pulumi.set(__self__, "http_basic_auths", http_basic_auths)
        pulumi.set(__self__, "label", label)
        pulumi.set(__self__, "repositories", repositories)
        pulumi.set(__self__, "search_paths", search_paths)
        pulumi.set(__self__, "ssh_auths", ssh_auths)
        pulumi.set(__self__, "uri", uri)

    @property
    @pulumi.getter(name="httpBasicAuths")
    def http_basic_auths(self) -> Sequence['outputs.GetSpringCloudServiceConfigServerGitSettingHttpBasicAuthResult']:
        """
        A `http_basic_auth` block as defined below.
        """
        return pulumi.get(self, "http_basic_auths")

    @property
    @pulumi.getter
    def label(self) -> str:
        """
        The default label of the Git repository, which is a branch name, tag name, or commit-id of the repository
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter
    def repositories(self) -> Sequence['outputs.GetSpringCloudServiceConfigServerGitSettingRepositoryResult']:
        """
        One or more `repository` blocks as defined below.
        """
        return pulumi.get(self, "repositories")

    @property
    @pulumi.getter(name="searchPaths")
    def search_paths(self) -> Sequence[str]:
        """
        An array of strings used to search subdirectories of the Git repository.
        """
        return pulumi.get(self, "search_paths")

    @property
    @pulumi.getter(name="sshAuths")
    def ssh_auths(self) -> Sequence['outputs.GetSpringCloudServiceConfigServerGitSettingSshAuthResult']:
        """
        A `ssh_auth` block as defined below.
        """
        return pulumi.get(self, "ssh_auths")

    @property
    @pulumi.getter
    def uri(self) -> str:
        """
        The URI of the Git repository
        """
        return pulumi.get(self, "uri")


@pulumi.output_type
class GetSpringCloudServiceConfigServerGitSettingHttpBasicAuthResult(dict):
    def __init__(__self__, *,
                 password: str,
                 username: str):
        """
        :param str password: The password used to access the HTTP Basic Authentication Git repository server.
        :param str username: The username used to access the HTTP Basic Authentication Git repository server.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The password used to access the HTTP Basic Authentication Git repository server.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The username used to access the HTTP Basic Authentication Git repository server.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class GetSpringCloudServiceConfigServerGitSettingRepositoryResult(dict):
    def __init__(__self__, *,
                 http_basic_auths: Sequence['outputs.GetSpringCloudServiceConfigServerGitSettingRepositoryHttpBasicAuthResult'],
                 label: str,
                 name: str,
                 patterns: Sequence[str],
                 search_paths: Sequence[str],
                 ssh_auths: Sequence['outputs.GetSpringCloudServiceConfigServerGitSettingRepositorySshAuthResult'],
                 uri: str):
        """
        :param Sequence['GetSpringCloudServiceConfigServerGitSettingRepositoryHttpBasicAuthArgs'] http_basic_auths: A `http_basic_auth` block as defined below.
        :param str label: The default label of the Git repository, which is a branch name, tag name, or commit-id of the repository
        :param str name: Specifies The name of the Spring Cloud Service resource.
        :param Sequence[str] patterns: An array of strings used to match an application name. For each pattern, use the `{application}/{profile}` format with wildcards.
        :param Sequence[str] search_paths: An array of strings used to search subdirectories of the Git repository.
        :param Sequence['GetSpringCloudServiceConfigServerGitSettingRepositorySshAuthArgs'] ssh_auths: A `ssh_auth` block as defined below.
        :param str uri: The URI of the Git repository
        """
        pulumi.set(__self__, "http_basic_auths", http_basic_auths)
        pulumi.set(__self__, "label", label)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "patterns", patterns)
        pulumi.set(__self__, "search_paths", search_paths)
        pulumi.set(__self__, "ssh_auths", ssh_auths)
        pulumi.set(__self__, "uri", uri)

    @property
    @pulumi.getter(name="httpBasicAuths")
    def http_basic_auths(self) -> Sequence['outputs.GetSpringCloudServiceConfigServerGitSettingRepositoryHttpBasicAuthResult']:
        """
        A `http_basic_auth` block as defined below.
        """
        return pulumi.get(self, "http_basic_auths")

    @property
    @pulumi.getter
    def label(self) -> str:
        """
        The default label of the Git repository, which is a branch name, tag name, or commit-id of the repository
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies The name of the Spring Cloud Service resource.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def patterns(self) -> Sequence[str]:
        """
        An array of strings used to match an application name. For each pattern, use the `{application}/{profile}` format with wildcards.
        """
        return pulumi.get(self, "patterns")

    @property
    @pulumi.getter(name="searchPaths")
    def search_paths(self) -> Sequence[str]:
        """
        An array of strings used to search subdirectories of the Git repository.
        """
        return pulumi.get(self, "search_paths")

    @property
    @pulumi.getter(name="sshAuths")
    def ssh_auths(self) -> Sequence['outputs.GetSpringCloudServiceConfigServerGitSettingRepositorySshAuthResult']:
        """
        A `ssh_auth` block as defined below.
        """
        return pulumi.get(self, "ssh_auths")

    @property
    @pulumi.getter
    def uri(self) -> str:
        """
        The URI of the Git repository
        """
        return pulumi.get(self, "uri")


@pulumi.output_type
class GetSpringCloudServiceConfigServerGitSettingRepositoryHttpBasicAuthResult(dict):
    def __init__(__self__, *,
                 password: str,
                 username: str):
        """
        :param str password: The password used to access the HTTP Basic Authentication Git repository server.
        :param str username: The username used to access the HTTP Basic Authentication Git repository server.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The password used to access the HTTP Basic Authentication Git repository server.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The username used to access the HTTP Basic Authentication Git repository server.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class GetSpringCloudServiceConfigServerGitSettingRepositorySshAuthResult(dict):
    def __init__(__self__, *,
                 host_key: str,
                 host_key_algorithm: str,
                 private_key: str,
                 strict_host_key_checking_enabled: bool):
        """
        :param str host_key: The host key of the Git repository server.
        :param str host_key_algorithm: The host key algorithm.
        :param str private_key: The SSH private key to access the Git repository, needed when the URI starts with `git@` or `ssh://`.
        :param bool strict_host_key_checking_enabled: Indicates whether the Config Server instance will fail to start if the host_key does not match.
        """
        pulumi.set(__self__, "host_key", host_key)
        pulumi.set(__self__, "host_key_algorithm", host_key_algorithm)
        pulumi.set(__self__, "private_key", private_key)
        pulumi.set(__self__, "strict_host_key_checking_enabled", strict_host_key_checking_enabled)

    @property
    @pulumi.getter(name="hostKey")
    def host_key(self) -> str:
        """
        The host key of the Git repository server.
        """
        return pulumi.get(self, "host_key")

    @property
    @pulumi.getter(name="hostKeyAlgorithm")
    def host_key_algorithm(self) -> str:
        """
        The host key algorithm.
        """
        return pulumi.get(self, "host_key_algorithm")

    @property
    @pulumi.getter(name="privateKey")
    def private_key(self) -> str:
        """
        The SSH private key to access the Git repository, needed when the URI starts with `git@` or `ssh://`.
        """
        return pulumi.get(self, "private_key")

    @property
    @pulumi.getter(name="strictHostKeyCheckingEnabled")
    def strict_host_key_checking_enabled(self) -> bool:
        """
        Indicates whether the Config Server instance will fail to start if the host_key does not match.
        """
        return pulumi.get(self, "strict_host_key_checking_enabled")


@pulumi.output_type
class GetSpringCloudServiceConfigServerGitSettingSshAuthResult(dict):
    def __init__(__self__, *,
                 host_key: str,
                 host_key_algorithm: str,
                 private_key: str,
                 strict_host_key_checking_enabled: bool):
        """
        :param str host_key: The host key of the Git repository server.
        :param str host_key_algorithm: The host key algorithm.
        :param str private_key: The SSH private key to access the Git repository, needed when the URI starts with `git@` or `ssh://`.
        :param bool strict_host_key_checking_enabled: Indicates whether the Config Server instance will fail to start if the host_key does not match.
        """
        pulumi.set(__self__, "host_key", host_key)
        pulumi.set(__self__, "host_key_algorithm", host_key_algorithm)
        pulumi.set(__self__, "private_key", private_key)
        pulumi.set(__self__, "strict_host_key_checking_enabled", strict_host_key_checking_enabled)

    @property
    @pulumi.getter(name="hostKey")
    def host_key(self) -> str:
        """
        The host key of the Git repository server.
        """
        return pulumi.get(self, "host_key")

    @property
    @pulumi.getter(name="hostKeyAlgorithm")
    def host_key_algorithm(self) -> str:
        """
        The host key algorithm.
        """
        return pulumi.get(self, "host_key_algorithm")

    @property
    @pulumi.getter(name="privateKey")
    def private_key(self) -> str:
        """
        The SSH private key to access the Git repository, needed when the URI starts with `git@` or `ssh://`.
        """
        return pulumi.get(self, "private_key")

    @property
    @pulumi.getter(name="strictHostKeyCheckingEnabled")
    def strict_host_key_checking_enabled(self) -> bool:
        """
        Indicates whether the Config Server instance will fail to start if the host_key does not match.
        """
        return pulumi.get(self, "strict_host_key_checking_enabled")


@pulumi.output_type
class GetSpringCloudServiceRequiredNetworkTrafficRuleResult(dict):
    def __init__(__self__, *,
                 direction: str,
                 fqdns: Sequence[str],
                 ip_addresses: Sequence[str],
                 port: int,
                 protocol: str):
        """
        :param str direction: The direction of required traffic. Possible values are `Inbound`, `Outbound`.
        :param Sequence[str] fqdns: The FQDN list of required traffic.
        :param Sequence[str] ip_addresses: The IP list of required traffic.
        :param int port: The port of required traffic.
        :param str protocol: The protocol of required traffic.
        """
        pulumi.set(__self__, "direction", direction)
        pulumi.set(__self__, "fqdns", fqdns)
        pulumi.set(__self__, "ip_addresses", ip_addresses)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "protocol", protocol)

    @property
    @pulumi.getter
    def direction(self) -> str:
        """
        The direction of required traffic. Possible values are `Inbound`, `Outbound`.
        """
        return pulumi.get(self, "direction")

    @property
    @pulumi.getter
    def fqdns(self) -> Sequence[str]:
        """
        The FQDN list of required traffic.
        """
        return pulumi.get(self, "fqdns")

    @property
    @pulumi.getter(name="ipAddresses")
    def ip_addresses(self) -> Sequence[str]:
        """
        The IP list of required traffic.
        """
        return pulumi.get(self, "ip_addresses")

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port of required traffic.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        The protocol of required traffic.
        """
        return pulumi.get(self, "protocol")


