# 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 copy
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from .. import _utilities

__all__ = [
    'SpringCloudApiPortalSsoArgs',
    'SpringCloudApiPortalSsoArgsDict',
    'SpringCloudAppCustomPersistentDiskArgs',
    'SpringCloudAppCustomPersistentDiskArgsDict',
    'SpringCloudAppIdentityArgs',
    'SpringCloudAppIdentityArgsDict',
    'SpringCloudAppIngressSettingsArgs',
    'SpringCloudAppIngressSettingsArgsDict',
    'SpringCloudAppPersistentDiskArgs',
    'SpringCloudAppPersistentDiskArgsDict',
    'SpringCloudBuildDeploymentQuotaArgs',
    'SpringCloudBuildDeploymentQuotaArgsDict',
    'SpringCloudBuildPackBindingLaunchArgs',
    'SpringCloudBuildPackBindingLaunchArgsDict',
    'SpringCloudBuilderBuildPackGroupArgs',
    'SpringCloudBuilderBuildPackGroupArgsDict',
    'SpringCloudBuilderStackArgs',
    'SpringCloudBuilderStackArgsDict',
    'SpringCloudConfigurationServiceRepositoryArgs',
    'SpringCloudConfigurationServiceRepositoryArgsDict',
    'SpringCloudConnectionAuthenticationArgs',
    'SpringCloudConnectionAuthenticationArgsDict',
    'SpringCloudConnectionSecretStoreArgs',
    'SpringCloudConnectionSecretStoreArgsDict',
    'SpringCloudContainerDeploymentQuotaArgs',
    'SpringCloudContainerDeploymentQuotaArgsDict',
    'SpringCloudCustomizedAcceleratorGitRepositoryArgs',
    'SpringCloudCustomizedAcceleratorGitRepositoryArgsDict',
    'SpringCloudCustomizedAcceleratorGitRepositoryBasicAuthArgs',
    'SpringCloudCustomizedAcceleratorGitRepositoryBasicAuthArgsDict',
    'SpringCloudCustomizedAcceleratorGitRepositorySshAuthArgs',
    'SpringCloudCustomizedAcceleratorGitRepositorySshAuthArgsDict',
    'SpringCloudDevToolPortalSsoArgs',
    'SpringCloudDevToolPortalSsoArgsDict',
    'SpringCloudGatewayApiMetadataArgs',
    'SpringCloudGatewayApiMetadataArgsDict',
    'SpringCloudGatewayClientAuthorizationArgs',
    'SpringCloudGatewayClientAuthorizationArgsDict',
    'SpringCloudGatewayCorsArgs',
    'SpringCloudGatewayCorsArgsDict',
    'SpringCloudGatewayLocalResponseCachePerInstanceArgs',
    'SpringCloudGatewayLocalResponseCachePerInstanceArgsDict',
    'SpringCloudGatewayLocalResponseCachePerRouteArgs',
    'SpringCloudGatewayLocalResponseCachePerRouteArgsDict',
    'SpringCloudGatewayQuotaArgs',
    'SpringCloudGatewayQuotaArgsDict',
    'SpringCloudGatewayRouteConfigOpenApiArgs',
    'SpringCloudGatewayRouteConfigOpenApiArgsDict',
    'SpringCloudGatewayRouteConfigRouteArgs',
    'SpringCloudGatewayRouteConfigRouteArgsDict',
    'SpringCloudGatewaySsoArgs',
    'SpringCloudGatewaySsoArgsDict',
    'SpringCloudJavaDeploymentQuotaArgs',
    'SpringCloudJavaDeploymentQuotaArgsDict',
    'SpringCloudServiceConfigServerGitSettingArgs',
    'SpringCloudServiceConfigServerGitSettingArgsDict',
    'SpringCloudServiceConfigServerGitSettingHttpBasicAuthArgs',
    'SpringCloudServiceConfigServerGitSettingHttpBasicAuthArgsDict',
    'SpringCloudServiceConfigServerGitSettingRepositoryArgs',
    'SpringCloudServiceConfigServerGitSettingRepositoryArgsDict',
    'SpringCloudServiceConfigServerGitSettingRepositoryHttpBasicAuthArgs',
    'SpringCloudServiceConfigServerGitSettingRepositoryHttpBasicAuthArgsDict',
    'SpringCloudServiceConfigServerGitSettingRepositorySshAuthArgs',
    'SpringCloudServiceConfigServerGitSettingRepositorySshAuthArgsDict',
    'SpringCloudServiceConfigServerGitSettingSshAuthArgs',
    'SpringCloudServiceConfigServerGitSettingSshAuthArgsDict',
    'SpringCloudServiceContainerRegistryArgs',
    'SpringCloudServiceContainerRegistryArgsDict',
    'SpringCloudServiceDefaultBuildServiceArgs',
    'SpringCloudServiceDefaultBuildServiceArgsDict',
    'SpringCloudServiceMarketplaceArgs',
    'SpringCloudServiceMarketplaceArgsDict',
    'SpringCloudServiceNetworkArgs',
    'SpringCloudServiceNetworkArgsDict',
    'SpringCloudServiceRequiredNetworkTrafficRuleArgs',
    'SpringCloudServiceRequiredNetworkTrafficRuleArgsDict',
    'SpringCloudServiceTraceArgs',
    'SpringCloudServiceTraceArgsDict',
]

MYPY = False

if not MYPY:
    class SpringCloudApiPortalSsoArgsDict(TypedDict):
        client_id: NotRequired[pulumi.Input[str]]
        """
        The public identifier for the application.
        """
        client_secret: NotRequired[pulumi.Input[str]]
        """
        The secret known only to the application and the authorization server.
        """
        issuer_uri: NotRequired[pulumi.Input[str]]
        """
        The URI of Issuer Identifier.
        """
        scopes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        It defines the specific actions applications can be allowed to do on a user's behalf.
        """
elif False:
    SpringCloudApiPortalSsoArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudApiPortalSsoArgs:
    def __init__(__self__, *,
                 client_id: Optional[pulumi.Input[str]] = None,
                 client_secret: Optional[pulumi.Input[str]] = None,
                 issuer_uri: Optional[pulumi.Input[str]] = None,
                 scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] client_id: The public identifier for the application.
        :param pulumi.Input[str] client_secret: The secret known only to the application and the authorization server.
        :param pulumi.Input[str] issuer_uri: The URI of Issuer Identifier.
        :param pulumi.Input[Sequence[pulumi.Input[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[pulumi.Input[str]]:
        """
        The public identifier for the application.
        """
        return pulumi.get(self, "client_id")

    @client_id.setter
    def client_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_id", value)

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

    @client_secret.setter
    def client_secret(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_secret", value)

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

    @issuer_uri.setter
    def issuer_uri(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "issuer_uri", value)

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

    @scopes.setter
    def scopes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "scopes", value)


if not MYPY:
    class SpringCloudAppCustomPersistentDiskArgsDict(TypedDict):
        mount_path: pulumi.Input[str]
        """
        The mount path of the persistent disk.
        """
        share_name: pulumi.Input[str]
        """
        The share name of the Azure File share.
        """
        storage_name: pulumi.Input[str]
        """
        The name of the Spring Cloud Storage.
        """
        mount_options: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        These are the mount options for a persistent disk.
        """
        read_only_enabled: NotRequired[pulumi.Input[bool]]
        """
        Indicates whether the persistent disk is a readOnly one.
        """
elif False:
    SpringCloudAppCustomPersistentDiskArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudAppCustomPersistentDiskArgs:
    def __init__(__self__, *,
                 mount_path: pulumi.Input[str],
                 share_name: pulumi.Input[str],
                 storage_name: pulumi.Input[str],
                 mount_options: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 read_only_enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] mount_path: The mount path of the persistent disk.
        :param pulumi.Input[str] share_name: The share name of the Azure File share.
        :param pulumi.Input[str] storage_name: The name of the Spring Cloud Storage.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] mount_options: These are the mount options for a persistent disk.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The mount path of the persistent disk.
        """
        return pulumi.get(self, "mount_path")

    @mount_path.setter
    def mount_path(self, value: pulumi.Input[str]):
        pulumi.set(self, "mount_path", value)

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

    @share_name.setter
    def share_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "share_name", value)

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

    @storage_name.setter
    def storage_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "storage_name", value)

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

    @mount_options.setter
    def mount_options(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "mount_options", value)

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

    @read_only_enabled.setter
    def read_only_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "read_only_enabled", value)


if not MYPY:
    class SpringCloudAppIdentityArgsDict(TypedDict):
        type: pulumi.Input[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).
        """
        identity_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        A list of User Assigned Managed Identity IDs to be assigned to this Spring Cloud Application.

        > **NOTE:** This is required when `type` is set to `UserAssigned` or `SystemAssigned, UserAssigned`.
        """
        principal_id: NotRequired[pulumi.Input[str]]
        """
        The Principal ID for the Service Principal associated with the Managed Service Identity of this Spring Cloud Application.
        """
        tenant_id: NotRequired[pulumi.Input[str]]
        """
        The Tenant ID for the Service Principal associated with the Managed Service Identity of this Spring Cloud Application.
        """
elif False:
    SpringCloudAppIdentityArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudAppIdentityArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str],
                 identity_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 principal_id: Optional[pulumi.Input[str]] = None,
                 tenant_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[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 pulumi.Input[Sequence[pulumi.Input[str]]] identity_ids: A list of User Assigned Managed Identity IDs to be assigned to this Spring Cloud Application.
               
               > **NOTE:** This is required when `type` is set to `UserAssigned` or `SystemAssigned, UserAssigned`.
        :param pulumi.Input[str] principal_id: The Principal ID for the Service Principal associated with the Managed Service Identity of this Spring Cloud Application.
        :param pulumi.Input[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) -> pulumi.Input[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")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)

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

        > **NOTE:** This is required when `type` is set to `UserAssigned` or `SystemAssigned, UserAssigned`.
        """
        return pulumi.get(self, "identity_ids")

    @identity_ids.setter
    def identity_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "identity_ids", value)

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> Optional[pulumi.Input[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")

    @principal_id.setter
    def principal_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "principal_id", value)

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[pulumi.Input[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")

    @tenant_id.setter
    def tenant_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tenant_id", value)


if not MYPY:
    class SpringCloudAppIngressSettingsArgsDict(TypedDict):
        backend_protocol: NotRequired[pulumi.Input[str]]
        """
        Specifies how ingress should communicate with this app backend service. Allowed values are `GRPC` and `Default`. Defaults to `Default`.
        """
        read_timeout_in_seconds: NotRequired[pulumi.Input[int]]
        """
        Specifies the ingress read time out in seconds. Defaults to `300`.
        """
        send_timeout_in_seconds: NotRequired[pulumi.Input[int]]
        """
        Specifies the ingress send time out in seconds. Defaults to `60`.
        """
        session_affinity: NotRequired[pulumi.Input[str]]
        """
        Specifies the type of the affinity, set this to `Cookie` to enable session affinity. Allowed values are `Cookie` and `None`. Defaults to `None`.
        """
        session_cookie_max_age: NotRequired[pulumi.Input[int]]
        """
        Specifies the time in seconds until the cookie expires.
        """
elif False:
    SpringCloudAppIngressSettingsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudAppIngressSettingsArgs:
    def __init__(__self__, *,
                 backend_protocol: Optional[pulumi.Input[str]] = None,
                 read_timeout_in_seconds: Optional[pulumi.Input[int]] = None,
                 send_timeout_in_seconds: Optional[pulumi.Input[int]] = None,
                 session_affinity: Optional[pulumi.Input[str]] = None,
                 session_cookie_max_age: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] backend_protocol: Specifies how ingress should communicate with this app backend service. Allowed values are `GRPC` and `Default`. Defaults to `Default`.
        :param pulumi.Input[int] read_timeout_in_seconds: Specifies the ingress read time out in seconds. Defaults to `300`.
        :param pulumi.Input[int] send_timeout_in_seconds: Specifies the ingress send time out in seconds. Defaults to `60`.
        :param pulumi.Input[str] session_affinity: Specifies the type of the affinity, set this to `Cookie` to enable session affinity. Allowed values are `Cookie` and `None`. Defaults to `None`.
        :param pulumi.Input[int] session_cookie_max_age: Specifies the time in seconds until the cookie expires.
        """
        if backend_protocol is not None:
            pulumi.set(__self__, "backend_protocol", backend_protocol)
        if read_timeout_in_seconds is not None:
            pulumi.set(__self__, "read_timeout_in_seconds", read_timeout_in_seconds)
        if send_timeout_in_seconds is not None:
            pulumi.set(__self__, "send_timeout_in_seconds", send_timeout_in_seconds)
        if session_affinity is not None:
            pulumi.set(__self__, "session_affinity", session_affinity)
        if session_cookie_max_age is not None:
            pulumi.set(__self__, "session_cookie_max_age", session_cookie_max_age)

    @property
    @pulumi.getter(name="backendProtocol")
    def backend_protocol(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies how ingress should communicate with this app backend service. Allowed values are `GRPC` and `Default`. Defaults to `Default`.
        """
        return pulumi.get(self, "backend_protocol")

    @backend_protocol.setter
    def backend_protocol(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "backend_protocol", value)

    @property
    @pulumi.getter(name="readTimeoutInSeconds")
    def read_timeout_in_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the ingress read time out in seconds. Defaults to `300`.
        """
        return pulumi.get(self, "read_timeout_in_seconds")

    @read_timeout_in_seconds.setter
    def read_timeout_in_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "read_timeout_in_seconds", value)

    @property
    @pulumi.getter(name="sendTimeoutInSeconds")
    def send_timeout_in_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the ingress send time out in seconds. Defaults to `60`.
        """
        return pulumi.get(self, "send_timeout_in_seconds")

    @send_timeout_in_seconds.setter
    def send_timeout_in_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "send_timeout_in_seconds", value)

    @property
    @pulumi.getter(name="sessionAffinity")
    def session_affinity(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the type of the affinity, set this to `Cookie` to enable session affinity. Allowed values are `Cookie` and `None`. Defaults to `None`.
        """
        return pulumi.get(self, "session_affinity")

    @session_affinity.setter
    def session_affinity(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "session_affinity", value)

    @property
    @pulumi.getter(name="sessionCookieMaxAge")
    def session_cookie_max_age(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the time in seconds until the cookie expires.
        """
        return pulumi.get(self, "session_cookie_max_age")

    @session_cookie_max_age.setter
    def session_cookie_max_age(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "session_cookie_max_age", value)


if not MYPY:
    class SpringCloudAppPersistentDiskArgsDict(TypedDict):
        size_in_gb: pulumi.Input[int]
        """
        Specifies the size of the persistent disk in GB. Possible values are between `0` and `50`.
        """
        mount_path: NotRequired[pulumi.Input[str]]
        """
        Specifies the mount path of the persistent disk. Defaults to `/persistent`.
        """
elif False:
    SpringCloudAppPersistentDiskArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudAppPersistentDiskArgs:
    def __init__(__self__, *,
                 size_in_gb: pulumi.Input[int],
                 mount_path: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] size_in_gb: Specifies the size of the persistent disk in GB. Possible values are between `0` and `50`.
        :param pulumi.Input[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) -> pulumi.Input[int]:
        """
        Specifies the size of the persistent disk in GB. Possible values are between `0` and `50`.
        """
        return pulumi.get(self, "size_in_gb")

    @size_in_gb.setter
    def size_in_gb(self, value: pulumi.Input[int]):
        pulumi.set(self, "size_in_gb", value)

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

    @mount_path.setter
    def mount_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mount_path", value)


if not MYPY:
    class SpringCloudBuildDeploymentQuotaArgsDict(TypedDict):
        cpu: NotRequired[pulumi.Input[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.

        > **Note:** `cpu` supports `500m` and `1` for Basic tier, `500m`, `1`, `2`, `3` and `4` for Standard tier.
        """
        memory: NotRequired[pulumi.Input[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.

        > **Note:** `memory` supports `512Mi`, `1Gi` and `2Gi` for Basic tier, `512Mi`, `1Gi`, `2Gi`, `3Gi`, `4Gi`, `5Gi`, `6Gi`, `7Gi`, and `8Gi` for Standard tier.
        """
elif False:
    SpringCloudBuildDeploymentQuotaArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudBuildDeploymentQuotaArgs:
    def __init__(__self__, *,
                 cpu: Optional[pulumi.Input[str]] = None,
                 memory: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[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.
               
               > **Note:** `cpu` supports `500m` and `1` for Basic tier, `500m`, `1`, `2`, `3` and `4` for Standard tier.
        :param pulumi.Input[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.
               
               > **Note:** `memory` supports `512Mi`, `1Gi` and `2Gi` for Basic tier, `512Mi`, `1Gi`, `2Gi`, `3Gi`, `4Gi`, `5Gi`, `6Gi`, `7Gi`, and `8Gi` for Standard tier.
        """
        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[pulumi.Input[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.

        > **Note:** `cpu` supports `500m` and `1` for Basic tier, `500m`, `1`, `2`, `3` and `4` for Standard tier.
        """
        return pulumi.get(self, "cpu")

    @cpu.setter
    def cpu(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cpu", value)

    @property
    @pulumi.getter
    def memory(self) -> Optional[pulumi.Input[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.

        > **Note:** `memory` supports `512Mi`, `1Gi` and `2Gi` for Basic tier, `512Mi`, `1Gi`, `2Gi`, `3Gi`, `4Gi`, `5Gi`, `6Gi`, `7Gi`, and `8Gi` for Standard tier.
        """
        return pulumi.get(self, "memory")

    @memory.setter
    def memory(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "memory", value)


if not MYPY:
    class SpringCloudBuildPackBindingLaunchArgsDict(TypedDict):
        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
        """
        Specifies a map of non-sensitive properties for launchProperties.
        """
        secrets: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
        """
        Specifies a map of sensitive properties for launchProperties.
        """
elif False:
    SpringCloudBuildPackBindingLaunchArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudBuildPackBindingLaunchArgs:
    def __init__(__self__, *,
                 properties: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 secrets: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] properties: Specifies a map of non-sensitive properties for launchProperties.
        :param pulumi.Input[Mapping[str, pulumi.Input[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[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        Specifies a map of non-sensitive properties for launchProperties.
        """
        return pulumi.get(self, "properties")

    @properties.setter
    def properties(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "properties", value)

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

    @secrets.setter
    def secrets(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "secrets", value)


if not MYPY:
    class SpringCloudBuilderBuildPackGroupArgsDict(TypedDict):
        name: pulumi.Input[str]
        """
        The name which should be used for this build pack group.
        """
        build_pack_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        Specifies a list of the build pack's ID.
        """
elif False:
    SpringCloudBuilderBuildPackGroupArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudBuilderBuildPackGroupArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 build_pack_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] name: The name which should be used for this build pack group.
        :param pulumi.Input[Sequence[pulumi.Input[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) -> pulumi.Input[str]:
        """
        The name which should be used for this build pack group.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

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

    @build_pack_ids.setter
    def build_pack_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "build_pack_ids", value)


if not MYPY:
    class SpringCloudBuilderStackArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        Specifies the ID of the ClusterStack.
        """
        version: pulumi.Input[str]
        """
        Specifies the version of the ClusterStack
        """
elif False:
    SpringCloudBuilderStackArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudBuilderStackArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str],
                 version: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: Specifies the ID of the ClusterStack.
        :param pulumi.Input[str] version: Specifies the version of the ClusterStack
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "version", version)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)

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

    @version.setter
    def version(self, value: pulumi.Input[str]):
        pulumi.set(self, "version", value)


if not MYPY:
    class SpringCloudConfigurationServiceRepositoryArgsDict(TypedDict):
        label: pulumi.Input[str]
        """
        Specifies the label of the repository.
        """
        name: pulumi.Input[str]
        """
        Specifies the name which should be used for this repository.
        """
        patterns: pulumi.Input[Sequence[pulumi.Input[str]]]
        """
        Specifies the collection of patterns of the repository.
        """
        uri: pulumi.Input[str]
        """
        Specifies the URI of the repository.
        """
        ca_certificate_id: NotRequired[pulumi.Input[str]]
        """
        Specifies the ID of the Certificate Authority used when retrieving the Git Repository via HTTPS.
        """
        host_key: NotRequired[pulumi.Input[str]]
        """
        Specifies the SSH public key of git repository.
        """
        host_key_algorithm: NotRequired[pulumi.Input[str]]
        """
        Specifies the SSH key algorithm of git repository.
        """
        password: NotRequired[pulumi.Input[str]]
        """
        Specifies the password of git repository basic auth.
        """
        private_key: NotRequired[pulumi.Input[str]]
        """
        Specifies the SSH private key of git repository.
        """
        search_paths: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        Specifies a list of searching path of the repository
        """
        strict_host_key_checking: NotRequired[pulumi.Input[bool]]
        """
        Specifies whether enable the strict host key checking.
        """
        username: NotRequired[pulumi.Input[str]]
        """
        Specifies the username of git repository basic auth.
        """
elif False:
    SpringCloudConfigurationServiceRepositoryArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudConfigurationServiceRepositoryArgs:
    def __init__(__self__, *,
                 label: pulumi.Input[str],
                 name: pulumi.Input[str],
                 patterns: pulumi.Input[Sequence[pulumi.Input[str]]],
                 uri: pulumi.Input[str],
                 ca_certificate_id: Optional[pulumi.Input[str]] = None,
                 host_key: Optional[pulumi.Input[str]] = None,
                 host_key_algorithm: Optional[pulumi.Input[str]] = None,
                 password: Optional[pulumi.Input[str]] = None,
                 private_key: Optional[pulumi.Input[str]] = None,
                 search_paths: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 strict_host_key_checking: Optional[pulumi.Input[bool]] = None,
                 username: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] label: Specifies the label of the repository.
        :param pulumi.Input[str] name: Specifies the name which should be used for this repository.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] patterns: Specifies the collection of patterns of the repository.
        :param pulumi.Input[str] uri: Specifies the URI of the repository.
        :param pulumi.Input[str] ca_certificate_id: Specifies the ID of the Certificate Authority used when retrieving the Git Repository via HTTPS.
        :param pulumi.Input[str] host_key: Specifies the SSH public key of git repository.
        :param pulumi.Input[str] host_key_algorithm: Specifies the SSH key algorithm of git repository.
        :param pulumi.Input[str] password: Specifies the password of git repository basic auth.
        :param pulumi.Input[str] private_key: Specifies the SSH private key of git repository.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] search_paths: Specifies a list of searching path of the repository
        :param pulumi.Input[bool] strict_host_key_checking: Specifies whether enable the strict host key checking.
        :param pulumi.Input[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 ca_certificate_id is not None:
            pulumi.set(__self__, "ca_certificate_id", ca_certificate_id)
        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) -> pulumi.Input[str]:
        """
        Specifies the label of the repository.
        """
        return pulumi.get(self, "label")

    @label.setter
    def label(self, value: pulumi.Input[str]):
        pulumi.set(self, "label", value)

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

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

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

    @patterns.setter
    def patterns(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "patterns", value)

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

    @uri.setter
    def uri(self, value: pulumi.Input[str]):
        pulumi.set(self, "uri", value)

    @property
    @pulumi.getter(name="caCertificateId")
    def ca_certificate_id(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the ID of the Certificate Authority used when retrieving the Git Repository via HTTPS.
        """
        return pulumi.get(self, "ca_certificate_id")

    @ca_certificate_id.setter
    def ca_certificate_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ca_certificate_id", value)

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

    @host_key.setter
    def host_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_key", value)

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

    @host_key_algorithm.setter
    def host_key_algorithm(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_key_algorithm", value)

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

    @password.setter
    def password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "password", value)

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

    @private_key.setter
    def private_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "private_key", value)

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

    @search_paths.setter
    def search_paths(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "search_paths", value)

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

    @strict_host_key_checking.setter
    def strict_host_key_checking(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "strict_host_key_checking", value)

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

    @username.setter
    def username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "username", value)


if not MYPY:
    class SpringCloudConnectionAuthenticationArgsDict(TypedDict):
        type: pulumi.Input[str]
        """
        The authentication type. Possible values are `systemAssignedIdentity`, `userAssignedIdentity`, `servicePrincipalSecret`, `servicePrincipalCertificate`, `secret`. Changing this forces a new resource to be created.
        """
        certificate: NotRequired[pulumi.Input[str]]
        """
        Service principal certificate for `servicePrincipal` auth. Should be specified when `type` is set to `servicePrincipalCertificate`.
        """
        client_id: NotRequired[pulumi.Input[str]]
        """
        Client ID for `userAssignedIdentity` or `servicePrincipal` auth. Should be specified when `type` is set to `servicePrincipalSecret` or `servicePrincipalCertificate`. When `type` is set to `userAssignedIdentity`, `client_id` and `subscription_id` should be either both specified or both not specified.
        """
        name: NotRequired[pulumi.Input[str]]
        """
        Username or account name for secret auth. `name` and `secret` should be either both specified or both not specified when `type` is set to `secret`.
        """
        principal_id: NotRequired[pulumi.Input[str]]
        """
        Principal ID for `servicePrincipal` auth. Should be specified when `type` is set to `servicePrincipalSecret` or `servicePrincipalCertificate`.
        """
        secret: NotRequired[pulumi.Input[str]]
        """
        Password or account key for secret auth. `secret` and `name` should be either both specified or both not specified when `type` is set to `secret`.
        """
        subscription_id: NotRequired[pulumi.Input[str]]
        """
        Subscription ID for `userAssignedIdentity`. `subscription_id` and `client_id` should be either both specified or both not specified.
        """
elif False:
    SpringCloudConnectionAuthenticationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudConnectionAuthenticationArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str],
                 certificate: Optional[pulumi.Input[str]] = None,
                 client_id: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 principal_id: Optional[pulumi.Input[str]] = None,
                 secret: Optional[pulumi.Input[str]] = None,
                 subscription_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] type: The authentication type. Possible values are `systemAssignedIdentity`, `userAssignedIdentity`, `servicePrincipalSecret`, `servicePrincipalCertificate`, `secret`. Changing this forces a new resource to be created.
        :param pulumi.Input[str] certificate: Service principal certificate for `servicePrincipal` auth. Should be specified when `type` is set to `servicePrincipalCertificate`.
        :param pulumi.Input[str] client_id: Client ID for `userAssignedIdentity` or `servicePrincipal` auth. Should be specified when `type` is set to `servicePrincipalSecret` or `servicePrincipalCertificate`. When `type` is set to `userAssignedIdentity`, `client_id` and `subscription_id` should be either both specified or both not specified.
        :param pulumi.Input[str] name: Username or account name for secret auth. `name` and `secret` should be either both specified or both not specified when `type` is set to `secret`.
        :param pulumi.Input[str] principal_id: Principal ID for `servicePrincipal` auth. Should be specified when `type` is set to `servicePrincipalSecret` or `servicePrincipalCertificate`.
        :param pulumi.Input[str] secret: Password or account key for secret auth. `secret` and `name` should be either both specified or both not specified when `type` is set to `secret`.
        :param pulumi.Input[str] subscription_id: Subscription ID for `userAssignedIdentity`. `subscription_id` and `client_id` should be either both specified or both not specified.
        """
        pulumi.set(__self__, "type", type)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if client_id is not None:
            pulumi.set(__self__, "client_id", client_id)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if principal_id is not None:
            pulumi.set(__self__, "principal_id", principal_id)
        if secret is not None:
            pulumi.set(__self__, "secret", secret)
        if subscription_id is not None:
            pulumi.set(__self__, "subscription_id", subscription_id)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        The authentication type. Possible values are `systemAssignedIdentity`, `userAssignedIdentity`, `servicePrincipalSecret`, `servicePrincipalCertificate`, `secret`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[str]]:
        """
        Service principal certificate for `servicePrincipal` auth. Should be specified when `type` is set to `servicePrincipalCertificate`.
        """
        return pulumi.get(self, "certificate")

    @certificate.setter
    def certificate(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "certificate", value)

    @property
    @pulumi.getter(name="clientId")
    def client_id(self) -> Optional[pulumi.Input[str]]:
        """
        Client ID for `userAssignedIdentity` or `servicePrincipal` auth. Should be specified when `type` is set to `servicePrincipalSecret` or `servicePrincipalCertificate`. When `type` is set to `userAssignedIdentity`, `client_id` and `subscription_id` should be either both specified or both not specified.
        """
        return pulumi.get(self, "client_id")

    @client_id.setter
    def client_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_id", value)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        Username or account name for secret auth. `name` and `secret` should be either both specified or both not specified when `type` is set to `secret`.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> Optional[pulumi.Input[str]]:
        """
        Principal ID for `servicePrincipal` auth. Should be specified when `type` is set to `servicePrincipalSecret` or `servicePrincipalCertificate`.
        """
        return pulumi.get(self, "principal_id")

    @principal_id.setter
    def principal_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "principal_id", value)

    @property
    @pulumi.getter
    def secret(self) -> Optional[pulumi.Input[str]]:
        """
        Password or account key for secret auth. `secret` and `name` should be either both specified or both not specified when `type` is set to `secret`.
        """
        return pulumi.get(self, "secret")

    @secret.setter
    def secret(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "secret", value)

    @property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> Optional[pulumi.Input[str]]:
        """
        Subscription ID for `userAssignedIdentity`. `subscription_id` and `client_id` should be either both specified or both not specified.
        """
        return pulumi.get(self, "subscription_id")

    @subscription_id.setter
    def subscription_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subscription_id", value)


if not MYPY:
    class SpringCloudConnectionSecretStoreArgsDict(TypedDict):
        key_vault_id: pulumi.Input[str]
        """
        The key vault id to store secret.
        """
elif False:
    SpringCloudConnectionSecretStoreArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudConnectionSecretStoreArgs:
    def __init__(__self__, *,
                 key_vault_id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key_vault_id: The key vault id to store secret.
        """
        pulumi.set(__self__, "key_vault_id", key_vault_id)

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> pulumi.Input[str]:
        """
        The key vault id to store secret.
        """
        return pulumi.get(self, "key_vault_id")

    @key_vault_id.setter
    def key_vault_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "key_vault_id", value)


if not MYPY:
    class SpringCloudContainerDeploymentQuotaArgsDict(TypedDict):
        cpu: NotRequired[pulumi.Input[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.

        > **Note:** `cpu` supports `500m` and `1` for Basic tier, `500m`, `1`, `2`, `3` and `4` for Standard tier.
        """
        memory: NotRequired[pulumi.Input[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.

        > **Note:** `memory` supports `512Mi`, `1Gi` and `2Gi` for Basic tier, `512Mi`, `1Gi`, `2Gi`, `3Gi`, `4Gi`, `5Gi`, `6Gi`, `7Gi`, and `8Gi` for Standard tier.
        """
elif False:
    SpringCloudContainerDeploymentQuotaArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudContainerDeploymentQuotaArgs:
    def __init__(__self__, *,
                 cpu: Optional[pulumi.Input[str]] = None,
                 memory: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[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.
               
               > **Note:** `cpu` supports `500m` and `1` for Basic tier, `500m`, `1`, `2`, `3` and `4` for Standard tier.
        :param pulumi.Input[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.
               
               > **Note:** `memory` supports `512Mi`, `1Gi` and `2Gi` for Basic tier, `512Mi`, `1Gi`, `2Gi`, `3Gi`, `4Gi`, `5Gi`, `6Gi`, `7Gi`, and `8Gi` for Standard tier.
        """
        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[pulumi.Input[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.

        > **Note:** `cpu` supports `500m` and `1` for Basic tier, `500m`, `1`, `2`, `3` and `4` for Standard tier.
        """
        return pulumi.get(self, "cpu")

    @cpu.setter
    def cpu(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cpu", value)

    @property
    @pulumi.getter
    def memory(self) -> Optional[pulumi.Input[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.

        > **Note:** `memory` supports `512Mi`, `1Gi` and `2Gi` for Basic tier, `512Mi`, `1Gi`, `2Gi`, `3Gi`, `4Gi`, `5Gi`, `6Gi`, `7Gi`, and `8Gi` for Standard tier.
        """
        return pulumi.get(self, "memory")

    @memory.setter
    def memory(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "memory", value)


if not MYPY:
    class SpringCloudCustomizedAcceleratorGitRepositoryArgsDict(TypedDict):
        url: pulumi.Input[str]
        """
        Specifies Git repository URL for the accelerator.
        """
        basic_auth: NotRequired[pulumi.Input['SpringCloudCustomizedAcceleratorGitRepositoryBasicAuthArgsDict']]
        """
        A `basic_auth` block as defined below. Conflicts with `git_repository[0].ssh_auth`. Changing this forces a new Spring Cloud Customized Accelerator to be created.
        """
        branch: NotRequired[pulumi.Input[str]]
        """
        Specifies the Git repository branch to be used.
        """
        ca_certificate_id: NotRequired[pulumi.Input[str]]
        """
        Specifies the ID of the CA Spring Cloud Certificate for https URL of Git repository.
        """
        commit: NotRequired[pulumi.Input[str]]
        """
        Specifies the Git repository commit to be used.
        """
        git_tag: NotRequired[pulumi.Input[str]]
        """
        Specifies the Git repository tag to be used.
        """
        interval_in_seconds: NotRequired[pulumi.Input[int]]
        """
        Specifies the interval for checking for updates to Git or image repository. It should be greater than 10.
        """
        path: NotRequired[pulumi.Input[str]]
        """
        Specifies the path under the git repository to be treated as the root directory of the accelerator or the fragment (depending on `accelerator_type`).
        """
        ssh_auth: NotRequired[pulumi.Input['SpringCloudCustomizedAcceleratorGitRepositorySshAuthArgsDict']]
        """
        A `ssh_auth` block as defined below. Conflicts with `git_repository[0].basic_auth`. Changing this forces a new Spring Cloud Customized Accelerator to be created.
        """
elif False:
    SpringCloudCustomizedAcceleratorGitRepositoryArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudCustomizedAcceleratorGitRepositoryArgs:
    def __init__(__self__, *,
                 url: pulumi.Input[str],
                 basic_auth: Optional[pulumi.Input['SpringCloudCustomizedAcceleratorGitRepositoryBasicAuthArgs']] = None,
                 branch: Optional[pulumi.Input[str]] = None,
                 ca_certificate_id: Optional[pulumi.Input[str]] = None,
                 commit: Optional[pulumi.Input[str]] = None,
                 git_tag: Optional[pulumi.Input[str]] = None,
                 interval_in_seconds: Optional[pulumi.Input[int]] = None,
                 path: Optional[pulumi.Input[str]] = None,
                 ssh_auth: Optional[pulumi.Input['SpringCloudCustomizedAcceleratorGitRepositorySshAuthArgs']] = None):
        """
        :param pulumi.Input[str] url: Specifies Git repository URL for the accelerator.
        :param pulumi.Input['SpringCloudCustomizedAcceleratorGitRepositoryBasicAuthArgs'] basic_auth: A `basic_auth` block as defined below. Conflicts with `git_repository[0].ssh_auth`. Changing this forces a new Spring Cloud Customized Accelerator to be created.
        :param pulumi.Input[str] branch: Specifies the Git repository branch to be used.
        :param pulumi.Input[str] ca_certificate_id: Specifies the ID of the CA Spring Cloud Certificate for https URL of Git repository.
        :param pulumi.Input[str] commit: Specifies the Git repository commit to be used.
        :param pulumi.Input[str] git_tag: Specifies the Git repository tag to be used.
        :param pulumi.Input[int] interval_in_seconds: Specifies the interval for checking for updates to Git or image repository. It should be greater than 10.
        :param pulumi.Input[str] path: Specifies the path under the git repository to be treated as the root directory of the accelerator or the fragment (depending on `accelerator_type`).
        :param pulumi.Input['SpringCloudCustomizedAcceleratorGitRepositorySshAuthArgs'] ssh_auth: A `ssh_auth` block as defined below. Conflicts with `git_repository[0].basic_auth`. Changing this forces a new Spring Cloud Customized Accelerator to be created.
        """
        pulumi.set(__self__, "url", url)
        if basic_auth is not None:
            pulumi.set(__self__, "basic_auth", basic_auth)
        if branch is not None:
            pulumi.set(__self__, "branch", branch)
        if ca_certificate_id is not None:
            pulumi.set(__self__, "ca_certificate_id", ca_certificate_id)
        if commit is not None:
            pulumi.set(__self__, "commit", commit)
        if git_tag is not None:
            pulumi.set(__self__, "git_tag", git_tag)
        if interval_in_seconds is not None:
            pulumi.set(__self__, "interval_in_seconds", interval_in_seconds)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if ssh_auth is not None:
            pulumi.set(__self__, "ssh_auth", ssh_auth)

    @property
    @pulumi.getter
    def url(self) -> pulumi.Input[str]:
        """
        Specifies Git repository URL for the accelerator.
        """
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: pulumi.Input[str]):
        pulumi.set(self, "url", value)

    @property
    @pulumi.getter(name="basicAuth")
    def basic_auth(self) -> Optional[pulumi.Input['SpringCloudCustomizedAcceleratorGitRepositoryBasicAuthArgs']]:
        """
        A `basic_auth` block as defined below. Conflicts with `git_repository[0].ssh_auth`. Changing this forces a new Spring Cloud Customized Accelerator to be created.
        """
        return pulumi.get(self, "basic_auth")

    @basic_auth.setter
    def basic_auth(self, value: Optional[pulumi.Input['SpringCloudCustomizedAcceleratorGitRepositoryBasicAuthArgs']]):
        pulumi.set(self, "basic_auth", value)

    @property
    @pulumi.getter
    def branch(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the Git repository branch to be used.
        """
        return pulumi.get(self, "branch")

    @branch.setter
    def branch(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "branch", value)

    @property
    @pulumi.getter(name="caCertificateId")
    def ca_certificate_id(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the ID of the CA Spring Cloud Certificate for https URL of Git repository.
        """
        return pulumi.get(self, "ca_certificate_id")

    @ca_certificate_id.setter
    def ca_certificate_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ca_certificate_id", value)

    @property
    @pulumi.getter
    def commit(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the Git repository commit to be used.
        """
        return pulumi.get(self, "commit")

    @commit.setter
    def commit(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "commit", value)

    @property
    @pulumi.getter(name="gitTag")
    def git_tag(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the Git repository tag to be used.
        """
        return pulumi.get(self, "git_tag")

    @git_tag.setter
    def git_tag(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "git_tag", value)

    @property
    @pulumi.getter(name="intervalInSeconds")
    def interval_in_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the interval for checking for updates to Git or image repository. It should be greater than 10.
        """
        return pulumi.get(self, "interval_in_seconds")

    @interval_in_seconds.setter
    def interval_in_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "interval_in_seconds", value)

    @property
    @pulumi.getter
    def path(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the path under the git repository to be treated as the root directory of the accelerator or the fragment (depending on `accelerator_type`).
        """
        return pulumi.get(self, "path")

    @path.setter
    def path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path", value)

    @property
    @pulumi.getter(name="sshAuth")
    def ssh_auth(self) -> Optional[pulumi.Input['SpringCloudCustomizedAcceleratorGitRepositorySshAuthArgs']]:
        """
        A `ssh_auth` block as defined below. Conflicts with `git_repository[0].basic_auth`. Changing this forces a new Spring Cloud Customized Accelerator to be created.
        """
        return pulumi.get(self, "ssh_auth")

    @ssh_auth.setter
    def ssh_auth(self, value: Optional[pulumi.Input['SpringCloudCustomizedAcceleratorGitRepositorySshAuthArgs']]):
        pulumi.set(self, "ssh_auth", value)


if not MYPY:
    class SpringCloudCustomizedAcceleratorGitRepositoryBasicAuthArgsDict(TypedDict):
        password: pulumi.Input[str]
        """
        Specifies the password of git repository basic auth.
        """
        username: pulumi.Input[str]
        """
        Specifies the username of git repository basic auth.
        """
elif False:
    SpringCloudCustomizedAcceleratorGitRepositoryBasicAuthArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudCustomizedAcceleratorGitRepositoryBasicAuthArgs:
    def __init__(__self__, *,
                 password: pulumi.Input[str],
                 username: pulumi.Input[str]):
        """
        :param pulumi.Input[str] password: Specifies the password of git repository basic auth.
        :param pulumi.Input[str] username: Specifies the username of git repository basic auth.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

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

    @password.setter
    def password(self, value: pulumi.Input[str]):
        pulumi.set(self, "password", value)

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

    @username.setter
    def username(self, value: pulumi.Input[str]):
        pulumi.set(self, "username", value)


if not MYPY:
    class SpringCloudCustomizedAcceleratorGitRepositorySshAuthArgsDict(TypedDict):
        private_key: pulumi.Input[str]
        """
        Specifies the Private SSH Key of git repository basic auth.
        """
        host_key: NotRequired[pulumi.Input[str]]
        """
        Specifies the Public SSH Key of git repository basic auth.
        """
        host_key_algorithm: NotRequired[pulumi.Input[str]]
        """
        Specifies the SSH Key algorithm of git repository basic auth.
        """
elif False:
    SpringCloudCustomizedAcceleratorGitRepositorySshAuthArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudCustomizedAcceleratorGitRepositorySshAuthArgs:
    def __init__(__self__, *,
                 private_key: pulumi.Input[str],
                 host_key: Optional[pulumi.Input[str]] = None,
                 host_key_algorithm: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] private_key: Specifies the Private SSH Key of git repository basic auth.
        :param pulumi.Input[str] host_key: Specifies the Public SSH Key of git repository basic auth.
        :param pulumi.Input[str] host_key_algorithm: Specifies the SSH Key algorithm of git repository basic auth.
        """
        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)

    @property
    @pulumi.getter(name="privateKey")
    def private_key(self) -> pulumi.Input[str]:
        """
        Specifies the Private SSH Key of git repository basic auth.
        """
        return pulumi.get(self, "private_key")

    @private_key.setter
    def private_key(self, value: pulumi.Input[str]):
        pulumi.set(self, "private_key", value)

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

    @host_key.setter
    def host_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_key", value)

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

    @host_key_algorithm.setter
    def host_key_algorithm(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_key_algorithm", value)


if not MYPY:
    class SpringCloudDevToolPortalSsoArgsDict(TypedDict):
        client_id: NotRequired[pulumi.Input[str]]
        """
        Specifies the public identifier for the application.
        """
        client_secret: NotRequired[pulumi.Input[str]]
        """
        Specifies the secret known only to the application and the authorization server.
        """
        metadata_url: NotRequired[pulumi.Input[str]]
        """
        Specifies the URI of a JSON file with generic OIDC provider configuration.
        """
        scopes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        Specifies a list of specific actions applications can be allowed to do on a user's behalf.
        """
elif False:
    SpringCloudDevToolPortalSsoArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudDevToolPortalSsoArgs:
    def __init__(__self__, *,
                 client_id: Optional[pulumi.Input[str]] = None,
                 client_secret: Optional[pulumi.Input[str]] = None,
                 metadata_url: Optional[pulumi.Input[str]] = None,
                 scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] client_id: Specifies the public identifier for the application.
        :param pulumi.Input[str] client_secret: Specifies the secret known only to the application and the authorization server.
        :param pulumi.Input[str] metadata_url: Specifies the URI of a JSON file with generic OIDC provider configuration.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] scopes: Specifies a list of 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 metadata_url is not None:
            pulumi.set(__self__, "metadata_url", metadata_url)
        if scopes is not None:
            pulumi.set(__self__, "scopes", scopes)

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

    @client_id.setter
    def client_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_id", value)

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

    @client_secret.setter
    def client_secret(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_secret", value)

    @property
    @pulumi.getter(name="metadataUrl")
    def metadata_url(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the URI of a JSON file with generic OIDC provider configuration.
        """
        return pulumi.get(self, "metadata_url")

    @metadata_url.setter
    def metadata_url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "metadata_url", value)

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

    @scopes.setter
    def scopes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "scopes", value)


if not MYPY:
    class SpringCloudGatewayApiMetadataArgsDict(TypedDict):
        description: NotRequired[pulumi.Input[str]]
        """
        Detailed description of the APIs available on the Gateway instance.
        """
        documentation_url: NotRequired[pulumi.Input[str]]
        """
        Location of additional documentation for the APIs available on the Gateway instance.
        """
        server_url: NotRequired[pulumi.Input[str]]
        """
        Base URL that API consumers will use to access APIs on the Gateway instance.
        """
        title: NotRequired[pulumi.Input[str]]
        """
        Specifies the title describing the context of the APIs available on the Gateway instance.
        """
        version: NotRequired[pulumi.Input[str]]
        """
        Specifies the version of APIs available on this Gateway instance.
        """
elif False:
    SpringCloudGatewayApiMetadataArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudGatewayApiMetadataArgs:
    def __init__(__self__, *,
                 description: Optional[pulumi.Input[str]] = None,
                 documentation_url: Optional[pulumi.Input[str]] = None,
                 server_url: Optional[pulumi.Input[str]] = None,
                 title: Optional[pulumi.Input[str]] = None,
                 version: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] description: Detailed description of the APIs available on the Gateway instance.
        :param pulumi.Input[str] documentation_url: Location of additional documentation for the APIs available on the Gateway instance.
        :param pulumi.Input[str] server_url: Base URL that API consumers will use to access APIs on the Gateway instance.
        :param pulumi.Input[str] title: Specifies the title describing the context of the APIs available on the Gateway instance.
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        Detailed description of the APIs available on the Gateway instance.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)

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

    @documentation_url.setter
    def documentation_url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "documentation_url", value)

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

    @server_url.setter
    def server_url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "server_url", value)

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

    @title.setter
    def title(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "title", value)

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

    @version.setter
    def version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "version", value)


if not MYPY:
    class SpringCloudGatewayClientAuthorizationArgsDict(TypedDict):
        certificate_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        Specifies the Spring Cloud Certificate IDs of the Spring Cloud Gateway.
        """
        verification_enabled: NotRequired[pulumi.Input[bool]]
        """
        Specifies whether the client certificate verification is enabled.
        """
elif False:
    SpringCloudGatewayClientAuthorizationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudGatewayClientAuthorizationArgs:
    def __init__(__self__, *,
                 certificate_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 verification_enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] certificate_ids: Specifies the Spring Cloud Certificate IDs of the Spring Cloud Gateway.
        :param pulumi.Input[bool] verification_enabled: Specifies whether the client certificate verification is enabled.
        """
        if certificate_ids is not None:
            pulumi.set(__self__, "certificate_ids", certificate_ids)
        if verification_enabled is not None:
            pulumi.set(__self__, "verification_enabled", verification_enabled)

    @property
    @pulumi.getter(name="certificateIds")
    def certificate_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the Spring Cloud Certificate IDs of the Spring Cloud Gateway.
        """
        return pulumi.get(self, "certificate_ids")

    @certificate_ids.setter
    def certificate_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "certificate_ids", value)

    @property
    @pulumi.getter(name="verificationEnabled")
    def verification_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies whether the client certificate verification is enabled.
        """
        return pulumi.get(self, "verification_enabled")

    @verification_enabled.setter
    def verification_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "verification_enabled", value)


if not MYPY:
    class SpringCloudGatewayCorsArgsDict(TypedDict):
        allowed_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        Allowed headers in cross-site requests. The special value `*` allows actual requests to send any header.
        """
        allowed_methods: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        Allowed HTTP methods on cross-site requests. The special value `*` allows all methods. If not set, `GET` and `HEAD` are allowed by default. Possible values are `DELETE`, `GET`, `HEAD`, `MERGE`, `POST`, `OPTIONS` and `PUT`.
        """
        allowed_origin_patterns: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        Allowed origin patterns to make cross-site requests.
        """
        allowed_origins: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        Allowed origins to make cross-site requests. The special value `*` allows all domains.
        """
        credentials_allowed: NotRequired[pulumi.Input[bool]]
        """
        is user credentials are supported on cross-site requests?
        """
        exposed_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        HTTP response headers to expose for cross-site requests.
        """
        max_age_seconds: NotRequired[pulumi.Input[int]]
        """
        How long, in seconds, the response from a pre-flight request can be cached by clients.
        """
elif False:
    SpringCloudGatewayCorsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudGatewayCorsArgs:
    def __init__(__self__, *,
                 allowed_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allowed_methods: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allowed_origin_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allowed_origins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 credentials_allowed: Optional[pulumi.Input[bool]] = None,
                 exposed_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 max_age_seconds: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_headers: Allowed headers in cross-site requests. The special value `*` allows actual requests to send any header.
        :param pulumi.Input[Sequence[pulumi.Input[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. Possible values are `DELETE`, `GET`, `HEAD`, `MERGE`, `POST`, `OPTIONS` and `PUT`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_origin_patterns: Allowed origin patterns to make cross-site requests.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_origins: Allowed origins to make cross-site requests. The special value `*` allows all domains.
        :param pulumi.Input[bool] credentials_allowed: is user credentials are supported on cross-site requests?
        :param pulumi.Input[Sequence[pulumi.Input[str]]] exposed_headers: HTTP response headers to expose for cross-site requests.
        :param pulumi.Input[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_origin_patterns is not None:
            pulumi.set(__self__, "allowed_origin_patterns", allowed_origin_patterns)
        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[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Allowed headers in cross-site requests. The special value `*` allows actual requests to send any header.
        """
        return pulumi.get(self, "allowed_headers")

    @allowed_headers.setter
    def allowed_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allowed_headers", value)

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

    @allowed_methods.setter
    def allowed_methods(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allowed_methods", value)

    @property
    @pulumi.getter(name="allowedOriginPatterns")
    def allowed_origin_patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Allowed origin patterns to make cross-site requests.
        """
        return pulumi.get(self, "allowed_origin_patterns")

    @allowed_origin_patterns.setter
    def allowed_origin_patterns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allowed_origin_patterns", value)

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

    @allowed_origins.setter
    def allowed_origins(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allowed_origins", value)

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

    @credentials_allowed.setter
    def credentials_allowed(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "credentials_allowed", value)

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

    @exposed_headers.setter
    def exposed_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "exposed_headers", value)

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

    @max_age_seconds.setter
    def max_age_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_age_seconds", value)


if not MYPY:
    class SpringCloudGatewayLocalResponseCachePerInstanceArgsDict(TypedDict):
        size: NotRequired[pulumi.Input[str]]
        """
        Specifies the maximum size of cache (10MB, 900KB, 1GB...) to determine if the cache needs to evict some entries.
        """
        time_to_live: NotRequired[pulumi.Input[str]]
        """
        Specifies the time before a cached entry is expired (300s, 5m, 1h...).
        """
elif False:
    SpringCloudGatewayLocalResponseCachePerInstanceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudGatewayLocalResponseCachePerInstanceArgs:
    def __init__(__self__, *,
                 size: Optional[pulumi.Input[str]] = None,
                 time_to_live: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] size: Specifies the maximum size of cache (10MB, 900KB, 1GB...) to determine if the cache needs to evict some entries.
        :param pulumi.Input[str] time_to_live: Specifies the time before a cached entry is expired (300s, 5m, 1h...).
        """
        if size is not None:
            pulumi.set(__self__, "size", size)
        if time_to_live is not None:
            pulumi.set(__self__, "time_to_live", time_to_live)

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the maximum size of cache (10MB, 900KB, 1GB...) to determine if the cache needs to evict some entries.
        """
        return pulumi.get(self, "size")

    @size.setter
    def size(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "size", value)

    @property
    @pulumi.getter(name="timeToLive")
    def time_to_live(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the time before a cached entry is expired (300s, 5m, 1h...).
        """
        return pulumi.get(self, "time_to_live")

    @time_to_live.setter
    def time_to_live(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "time_to_live", value)


if not MYPY:
    class SpringCloudGatewayLocalResponseCachePerRouteArgsDict(TypedDict):
        size: NotRequired[pulumi.Input[str]]
        """
        Specifies the maximum size of cache (10MB, 900KB, 1GB...) to determine if the cache needs to evict some entries.
        """
        time_to_live: NotRequired[pulumi.Input[str]]
        """
        Specifies the time before a cached entry is expired (300s, 5m, 1h...).
        """
elif False:
    SpringCloudGatewayLocalResponseCachePerRouteArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudGatewayLocalResponseCachePerRouteArgs:
    def __init__(__self__, *,
                 size: Optional[pulumi.Input[str]] = None,
                 time_to_live: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] size: Specifies the maximum size of cache (10MB, 900KB, 1GB...) to determine if the cache needs to evict some entries.
        :param pulumi.Input[str] time_to_live: Specifies the time before a cached entry is expired (300s, 5m, 1h...).
        """
        if size is not None:
            pulumi.set(__self__, "size", size)
        if time_to_live is not None:
            pulumi.set(__self__, "time_to_live", time_to_live)

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the maximum size of cache (10MB, 900KB, 1GB...) to determine if the cache needs to evict some entries.
        """
        return pulumi.get(self, "size")

    @size.setter
    def size(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "size", value)

    @property
    @pulumi.getter(name="timeToLive")
    def time_to_live(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the time before a cached entry is expired (300s, 5m, 1h...).
        """
        return pulumi.get(self, "time_to_live")

    @time_to_live.setter
    def time_to_live(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "time_to_live", value)


if not MYPY:
    class SpringCloudGatewayQuotaArgsDict(TypedDict):
        cpu: NotRequired[pulumi.Input[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.

        > **Note:** `cpu` supports `500m` and `1` for Basic tier, `500m`, `1`, `2`, `3` and `4` for Standard tier.
        """
        memory: NotRequired[pulumi.Input[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 `2Gi` if not specified.

        > **Note:** `memory` supports `512Mi`, `1Gi` and `2Gi` for Basic tier, `512Mi`, `1Gi`, `2Gi`, `3Gi`, `4Gi`, `5Gi`, `6Gi`, `7Gi`, and `8Gi` for Standard tier.
        """
elif False:
    SpringCloudGatewayQuotaArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudGatewayQuotaArgs:
    def __init__(__self__, *,
                 cpu: Optional[pulumi.Input[str]] = None,
                 memory: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[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.
               
               > **Note:** `cpu` supports `500m` and `1` for Basic tier, `500m`, `1`, `2`, `3` and `4` for Standard tier.
        :param pulumi.Input[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 `2Gi` if not specified.
               
               > **Note:** `memory` supports `512Mi`, `1Gi` and `2Gi` for Basic tier, `512Mi`, `1Gi`, `2Gi`, `3Gi`, `4Gi`, `5Gi`, `6Gi`, `7Gi`, and `8Gi` for Standard tier.
        """
        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[pulumi.Input[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.

        > **Note:** `cpu` supports `500m` and `1` for Basic tier, `500m`, `1`, `2`, `3` and `4` for Standard tier.
        """
        return pulumi.get(self, "cpu")

    @cpu.setter
    def cpu(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cpu", value)

    @property
    @pulumi.getter
    def memory(self) -> Optional[pulumi.Input[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 `2Gi` if not specified.

        > **Note:** `memory` supports `512Mi`, `1Gi` and `2Gi` for Basic tier, `512Mi`, `1Gi`, `2Gi`, `3Gi`, `4Gi`, `5Gi`, `6Gi`, `7Gi`, and `8Gi` for Standard tier.
        """
        return pulumi.get(self, "memory")

    @memory.setter
    def memory(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "memory", value)


if not MYPY:
    class SpringCloudGatewayRouteConfigOpenApiArgsDict(TypedDict):
        uri: NotRequired[pulumi.Input[str]]
        """
        The URI of OpenAPI specification.
        """
elif False:
    SpringCloudGatewayRouteConfigOpenApiArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudGatewayRouteConfigOpenApiArgs:
    def __init__(__self__, *,
                 uri: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] uri: The URI of OpenAPI specification.
        """
        if uri is not None:
            pulumi.set(__self__, "uri", uri)

    @property
    @pulumi.getter
    def uri(self) -> Optional[pulumi.Input[str]]:
        """
        The URI of OpenAPI specification.
        """
        return pulumi.get(self, "uri")

    @uri.setter
    def uri(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "uri", value)


if not MYPY:
    class SpringCloudGatewayRouteConfigRouteArgsDict(TypedDict):
        order: pulumi.Input[int]
        """
        Specifies the route processing order.
        """
        classification_tags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        Specifies the classification tags which will be applied to methods in the generated OpenAPI documentation.
        """
        description: NotRequired[pulumi.Input[str]]
        """
        Specifies the description which will be applied to methods in the generated OpenAPI documentation.
        """
        filters: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        Specifies a list of filters which are used to modify the request before sending it to the target endpoint, or the received response.
        """
        predicates: NotRequired[pulumi.Input[Sequence[pulumi.Input[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.
        """
        sso_validation_enabled: NotRequired[pulumi.Input[bool]]
        """
        Should the sso validation be enabled?
        """
        title: NotRequired[pulumi.Input[str]]
        """
        Specifies the title which will be applied to methods in the generated OpenAPI documentation.
        """
        token_relay: NotRequired[pulumi.Input[bool]]
        """
        Should pass currently-authenticated user's identity token to application service?
        """
        uri: NotRequired[pulumi.Input[str]]
        """
        Specifies the full uri which will override `appName`.
        """
elif False:
    SpringCloudGatewayRouteConfigRouteArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudGatewayRouteConfigRouteArgs:
    def __init__(__self__, *,
                 order: pulumi.Input[int],
                 classification_tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 filters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 predicates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 sso_validation_enabled: Optional[pulumi.Input[bool]] = None,
                 title: Optional[pulumi.Input[str]] = None,
                 token_relay: Optional[pulumi.Input[bool]] = None,
                 uri: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] order: Specifies the route processing order.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] classification_tags: Specifies the classification tags which will be applied to methods in the generated OpenAPI documentation.
        :param pulumi.Input[str] description: Specifies the description which will be applied to methods in the generated OpenAPI documentation.
        :param pulumi.Input[Sequence[pulumi.Input[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 pulumi.Input[Sequence[pulumi.Input[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 pulumi.Input[bool] sso_validation_enabled: Should the sso validation be enabled?
        :param pulumi.Input[str] title: Specifies the title which will be applied to methods in the generated OpenAPI documentation.
        :param pulumi.Input[bool] token_relay: Should pass currently-authenticated user's identity token to application service?
        :param pulumi.Input[str] uri: Specifies the full uri which will override `appName`.
        """
        pulumi.set(__self__, "order", order)
        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 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
    def order(self) -> pulumi.Input[int]:
        """
        Specifies the route processing order.
        """
        return pulumi.get(self, "order")

    @order.setter
    def order(self, value: pulumi.Input[int]):
        pulumi.set(self, "order", value)

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

    @classification_tags.setter
    def classification_tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "classification_tags", value)

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

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)

    @property
    @pulumi.getter
    def filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[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")

    @filters.setter
    def filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "filters", value)

    @property
    @pulumi.getter
    def predicates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[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")

    @predicates.setter
    def predicates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "predicates", value)

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

    @sso_validation_enabled.setter
    def sso_validation_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "sso_validation_enabled", value)

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

    @title.setter
    def title(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "title", value)

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

    @token_relay.setter
    def token_relay(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "token_relay", value)

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

    @uri.setter
    def uri(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "uri", value)


if not MYPY:
    class SpringCloudGatewaySsoArgsDict(TypedDict):
        client_id: NotRequired[pulumi.Input[str]]
        """
        The public identifier for the application.
        """
        client_secret: NotRequired[pulumi.Input[str]]
        """
        The secret known only to the application and the authorization server.
        """
        issuer_uri: NotRequired[pulumi.Input[str]]
        """
        The URI of Issuer Identifier.
        """
        scopes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        It defines the specific actions applications can be allowed to do on a user's behalf.
        """
elif False:
    SpringCloudGatewaySsoArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudGatewaySsoArgs:
    def __init__(__self__, *,
                 client_id: Optional[pulumi.Input[str]] = None,
                 client_secret: Optional[pulumi.Input[str]] = None,
                 issuer_uri: Optional[pulumi.Input[str]] = None,
                 scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] client_id: The public identifier for the application.
        :param pulumi.Input[str] client_secret: The secret known only to the application and the authorization server.
        :param pulumi.Input[str] issuer_uri: The URI of Issuer Identifier.
        :param pulumi.Input[Sequence[pulumi.Input[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[pulumi.Input[str]]:
        """
        The public identifier for the application.
        """
        return pulumi.get(self, "client_id")

    @client_id.setter
    def client_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_id", value)

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

    @client_secret.setter
    def client_secret(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_secret", value)

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

    @issuer_uri.setter
    def issuer_uri(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "issuer_uri", value)

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

    @scopes.setter
    def scopes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "scopes", value)


if not MYPY:
    class SpringCloudJavaDeploymentQuotaArgsDict(TypedDict):
        cpu: NotRequired[pulumi.Input[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.

        > **Note:** `cpu` supports `500m` and `1` for Basic tier, `500m`, `1`, `2`, `3` and `4` for Standard tier.
        """
        memory: NotRequired[pulumi.Input[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.

        > **Note:** `memory` supports `512Mi`, `1Gi` and `2Gi` for Basic tier, `512Mi`, `1Gi`, `2Gi`, `3Gi`, `4Gi`, `5Gi`, `6Gi`, `7Gi`, and `8Gi` for Standard tier.
        """
elif False:
    SpringCloudJavaDeploymentQuotaArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudJavaDeploymentQuotaArgs:
    def __init__(__self__, *,
                 cpu: Optional[pulumi.Input[str]] = None,
                 memory: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[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.
               
               > **Note:** `cpu` supports `500m` and `1` for Basic tier, `500m`, `1`, `2`, `3` and `4` for Standard tier.
        :param pulumi.Input[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.
               
               > **Note:** `memory` supports `512Mi`, `1Gi` and `2Gi` for Basic tier, `512Mi`, `1Gi`, `2Gi`, `3Gi`, `4Gi`, `5Gi`, `6Gi`, `7Gi`, and `8Gi` for Standard tier.
        """
        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[pulumi.Input[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.

        > **Note:** `cpu` supports `500m` and `1` for Basic tier, `500m`, `1`, `2`, `3` and `4` for Standard tier.
        """
        return pulumi.get(self, "cpu")

    @cpu.setter
    def cpu(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cpu", value)

    @property
    @pulumi.getter
    def memory(self) -> Optional[pulumi.Input[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.

        > **Note:** `memory` supports `512Mi`, `1Gi` and `2Gi` for Basic tier, `512Mi`, `1Gi`, `2Gi`, `3Gi`, `4Gi`, `5Gi`, `6Gi`, `7Gi`, and `8Gi` for Standard tier.
        """
        return pulumi.get(self, "memory")

    @memory.setter
    def memory(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "memory", value)


if not MYPY:
    class SpringCloudServiceConfigServerGitSettingArgsDict(TypedDict):
        uri: pulumi.Input[str]
        """
        The URI of the default Git repository used as the Config Server back end, should be started with `http://`, `https://`, `git@`, or `ssh://`.
        """
        http_basic_auth: NotRequired[pulumi.Input['SpringCloudServiceConfigServerGitSettingHttpBasicAuthArgsDict']]
        """
        A `http_basic_auth` block as defined below.
        """
        label: NotRequired[pulumi.Input[str]]
        """
        The default label of the Git repository, should be the branch name, tag name, or commit-id of the repository.
        """
        repositories: NotRequired[pulumi.Input[Sequence[pulumi.Input['SpringCloudServiceConfigServerGitSettingRepositoryArgsDict']]]]
        """
        One or more `repository` blocks as defined below.
        """
        search_paths: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        An array of strings used to search subdirectories of the Git repository.
        """
        ssh_auth: NotRequired[pulumi.Input['SpringCloudServiceConfigServerGitSettingSshAuthArgsDict']]
        """
        A `ssh_auth` block as defined below.
        """
elif False:
    SpringCloudServiceConfigServerGitSettingArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudServiceConfigServerGitSettingArgs:
    def __init__(__self__, *,
                 uri: pulumi.Input[str],
                 http_basic_auth: Optional[pulumi.Input['SpringCloudServiceConfigServerGitSettingHttpBasicAuthArgs']] = None,
                 label: Optional[pulumi.Input[str]] = None,
                 repositories: Optional[pulumi.Input[Sequence[pulumi.Input['SpringCloudServiceConfigServerGitSettingRepositoryArgs']]]] = None,
                 search_paths: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ssh_auth: Optional[pulumi.Input['SpringCloudServiceConfigServerGitSettingSshAuthArgs']] = None):
        """
        :param pulumi.Input[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 pulumi.Input['SpringCloudServiceConfigServerGitSettingHttpBasicAuthArgs'] http_basic_auth: A `http_basic_auth` block as defined below.
        :param pulumi.Input[str] label: The default label of the Git repository, should be the branch name, tag name, or commit-id of the repository.
        :param pulumi.Input[Sequence[pulumi.Input['SpringCloudServiceConfigServerGitSettingRepositoryArgs']]] repositories: One or more `repository` blocks as defined below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] search_paths: An array of strings used to search subdirectories of the Git repository.
        :param pulumi.Input['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) -> pulumi.Input[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")

    @uri.setter
    def uri(self, value: pulumi.Input[str]):
        pulumi.set(self, "uri", value)

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

    @http_basic_auth.setter
    def http_basic_auth(self, value: Optional[pulumi.Input['SpringCloudServiceConfigServerGitSettingHttpBasicAuthArgs']]):
        pulumi.set(self, "http_basic_auth", value)

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[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")

    @label.setter
    def label(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "label", value)

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

    @repositories.setter
    def repositories(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SpringCloudServiceConfigServerGitSettingRepositoryArgs']]]]):
        pulumi.set(self, "repositories", value)

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

    @search_paths.setter
    def search_paths(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "search_paths", value)

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

    @ssh_auth.setter
    def ssh_auth(self, value: Optional[pulumi.Input['SpringCloudServiceConfigServerGitSettingSshAuthArgs']]):
        pulumi.set(self, "ssh_auth", value)


if not MYPY:
    class SpringCloudServiceConfigServerGitSettingHttpBasicAuthArgsDict(TypedDict):
        password: pulumi.Input[str]
        """
        The password used to access the Git repository server, required when the Git repository server supports HTTP Basic Authentication.
        """
        username: pulumi.Input[str]
        """
        The username that's used to access the Git repository server, required when the Git repository server supports HTTP Basic Authentication.
        """
elif False:
    SpringCloudServiceConfigServerGitSettingHttpBasicAuthArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudServiceConfigServerGitSettingHttpBasicAuthArgs:
    def __init__(__self__, *,
                 password: pulumi.Input[str],
                 username: pulumi.Input[str]):
        """
        :param pulumi.Input[str] password: The password used to access the Git repository server, required when the Git repository server supports HTTP Basic Authentication.
        :param pulumi.Input[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) -> pulumi.Input[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")

    @password.setter
    def password(self, value: pulumi.Input[str]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter
    def username(self) -> pulumi.Input[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")

    @username.setter
    def username(self, value: pulumi.Input[str]):
        pulumi.set(self, "username", value)


if not MYPY:
    class SpringCloudServiceConfigServerGitSettingRepositoryArgsDict(TypedDict):
        name: pulumi.Input[str]
        """
        A name to identify on the Git repository, required only if repos exists.
        """
        uri: pulumi.Input[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://`.
        """
        http_basic_auth: NotRequired[pulumi.Input['SpringCloudServiceConfigServerGitSettingRepositoryHttpBasicAuthArgsDict']]
        """
        A `http_basic_auth` block as defined below.
        """
        label: NotRequired[pulumi.Input[str]]
        """
        The default label of the Git repository, should be the branch name, tag name, or commit-id of the repository.
        """
        patterns: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        An array of strings used to match an application name. For each pattern, use the `{application}/{profile}` format with wildcards.
        """
        search_paths: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        An array of strings used to search subdirectories of the Git repository.
        """
        ssh_auth: NotRequired[pulumi.Input['SpringCloudServiceConfigServerGitSettingRepositorySshAuthArgsDict']]
        """
        A `ssh_auth` block as defined below.
        """
elif False:
    SpringCloudServiceConfigServerGitSettingRepositoryArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudServiceConfigServerGitSettingRepositoryArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 uri: pulumi.Input[str],
                 http_basic_auth: Optional[pulumi.Input['SpringCloudServiceConfigServerGitSettingRepositoryHttpBasicAuthArgs']] = None,
                 label: Optional[pulumi.Input[str]] = None,
                 patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 search_paths: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ssh_auth: Optional[pulumi.Input['SpringCloudServiceConfigServerGitSettingRepositorySshAuthArgs']] = None):
        """
        :param pulumi.Input[str] name: A name to identify on the Git repository, required only if repos exists.
        :param pulumi.Input[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 pulumi.Input['SpringCloudServiceConfigServerGitSettingRepositoryHttpBasicAuthArgs'] http_basic_auth: A `http_basic_auth` block as defined below.
        :param pulumi.Input[str] label: The default label of the Git repository, should be the branch name, tag name, or commit-id of the repository.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] patterns: An array of strings used to match an application name. For each pattern, use the `{application}/{profile}` format with wildcards.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] search_paths: An array of strings used to search subdirectories of the Git repository.
        :param pulumi.Input['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) -> pulumi.Input[str]:
        """
        A name to identify on the Git repository, required only if repos exists.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def uri(self) -> pulumi.Input[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")

    @uri.setter
    def uri(self, value: pulumi.Input[str]):
        pulumi.set(self, "uri", value)

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

    @http_basic_auth.setter
    def http_basic_auth(self, value: Optional[pulumi.Input['SpringCloudServiceConfigServerGitSettingRepositoryHttpBasicAuthArgs']]):
        pulumi.set(self, "http_basic_auth", value)

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[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")

    @label.setter
    def label(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "label", value)

    @property
    @pulumi.getter
    def patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[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")

    @patterns.setter
    def patterns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "patterns", value)

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

    @search_paths.setter
    def search_paths(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "search_paths", value)

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

    @ssh_auth.setter
    def ssh_auth(self, value: Optional[pulumi.Input['SpringCloudServiceConfigServerGitSettingRepositorySshAuthArgs']]):
        pulumi.set(self, "ssh_auth", value)


if not MYPY:
    class SpringCloudServiceConfigServerGitSettingRepositoryHttpBasicAuthArgsDict(TypedDict):
        password: pulumi.Input[str]
        """
        The password used to access the Git repository server, required when the Git repository server supports HTTP Basic Authentication.
        """
        username: pulumi.Input[str]
        """
        The username that's used to access the Git repository server, required when the Git repository server supports HTTP Basic Authentication.
        """
elif False:
    SpringCloudServiceConfigServerGitSettingRepositoryHttpBasicAuthArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudServiceConfigServerGitSettingRepositoryHttpBasicAuthArgs:
    def __init__(__self__, *,
                 password: pulumi.Input[str],
                 username: pulumi.Input[str]):
        """
        :param pulumi.Input[str] password: The password used to access the Git repository server, required when the Git repository server supports HTTP Basic Authentication.
        :param pulumi.Input[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) -> pulumi.Input[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")

    @password.setter
    def password(self, value: pulumi.Input[str]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter
    def username(self) -> pulumi.Input[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")

    @username.setter
    def username(self, value: pulumi.Input[str]):
        pulumi.set(self, "username", value)


if not MYPY:
    class SpringCloudServiceConfigServerGitSettingRepositorySshAuthArgsDict(TypedDict):
        private_key: pulumi.Input[str]
        """
        The SSH private key to access the Git repository, required when the URI starts with `git@` or `ssh://`.
        """
        host_key: NotRequired[pulumi.Input[str]]
        """
        The host key of the Git repository server, should not include the algorithm prefix as covered by `host-key-algorithm`.
        """
        host_key_algorithm: NotRequired[pulumi.Input[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.
        """
        strict_host_key_checking_enabled: NotRequired[pulumi.Input[bool]]
        """
        Indicates whether the Config Server instance will fail to start if the host_key does not match. Defaults to `true`.
        """
elif False:
    SpringCloudServiceConfigServerGitSettingRepositorySshAuthArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudServiceConfigServerGitSettingRepositorySshAuthArgs:
    def __init__(__self__, *,
                 private_key: pulumi.Input[str],
                 host_key: Optional[pulumi.Input[str]] = None,
                 host_key_algorithm: Optional[pulumi.Input[str]] = None,
                 strict_host_key_checking_enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] private_key: The SSH private key to access the Git repository, required when the URI starts with `git@` or `ssh://`.
        :param pulumi.Input[str] host_key: The host key of the Git repository server, should not include the algorithm prefix as covered by `host-key-algorithm`.
        :param pulumi.Input[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 pulumi.Input[bool] strict_host_key_checking_enabled: Indicates whether the Config Server instance will fail to start if the host_key does not match. Defaults to `true`.
        """
        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) -> pulumi.Input[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")

    @private_key.setter
    def private_key(self, value: pulumi.Input[str]):
        pulumi.set(self, "private_key", value)

    @property
    @pulumi.getter(name="hostKey")
    def host_key(self) -> Optional[pulumi.Input[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")

    @host_key.setter
    def host_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_key", value)

    @property
    @pulumi.getter(name="hostKeyAlgorithm")
    def host_key_algorithm(self) -> Optional[pulumi.Input[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")

    @host_key_algorithm.setter
    def host_key_algorithm(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_key_algorithm", value)

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

    @strict_host_key_checking_enabled.setter
    def strict_host_key_checking_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "strict_host_key_checking_enabled", value)


if not MYPY:
    class SpringCloudServiceConfigServerGitSettingSshAuthArgsDict(TypedDict):
        private_key: pulumi.Input[str]
        """
        The SSH private key to access the Git repository, required when the URI starts with `git@` or `ssh://`.
        """
        host_key: NotRequired[pulumi.Input[str]]
        """
        The host key of the Git repository server, should not include the algorithm prefix as covered by `host-key-algorithm`.
        """
        host_key_algorithm: NotRequired[pulumi.Input[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.
        """
        strict_host_key_checking_enabled: NotRequired[pulumi.Input[bool]]
        """
        Indicates whether the Config Server instance will fail to start if the host_key does not match. Defaults to `true`.
        """
elif False:
    SpringCloudServiceConfigServerGitSettingSshAuthArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudServiceConfigServerGitSettingSshAuthArgs:
    def __init__(__self__, *,
                 private_key: pulumi.Input[str],
                 host_key: Optional[pulumi.Input[str]] = None,
                 host_key_algorithm: Optional[pulumi.Input[str]] = None,
                 strict_host_key_checking_enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] private_key: The SSH private key to access the Git repository, required when the URI starts with `git@` or `ssh://`.
        :param pulumi.Input[str] host_key: The host key of the Git repository server, should not include the algorithm prefix as covered by `host-key-algorithm`.
        :param pulumi.Input[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 pulumi.Input[bool] strict_host_key_checking_enabled: Indicates whether the Config Server instance will fail to start if the host_key does not match. Defaults to `true`.
        """
        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) -> pulumi.Input[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")

    @private_key.setter
    def private_key(self, value: pulumi.Input[str]):
        pulumi.set(self, "private_key", value)

    @property
    @pulumi.getter(name="hostKey")
    def host_key(self) -> Optional[pulumi.Input[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")

    @host_key.setter
    def host_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_key", value)

    @property
    @pulumi.getter(name="hostKeyAlgorithm")
    def host_key_algorithm(self) -> Optional[pulumi.Input[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")

    @host_key_algorithm.setter
    def host_key_algorithm(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_key_algorithm", value)

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

    @strict_host_key_checking_enabled.setter
    def strict_host_key_checking_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "strict_host_key_checking_enabled", value)


if not MYPY:
    class SpringCloudServiceContainerRegistryArgsDict(TypedDict):
        name: pulumi.Input[str]
        """
        Specifies the name of the container registry.
        """
        password: pulumi.Input[str]
        """
        Specifies the password of the container registry.
        """
        server: pulumi.Input[str]
        """
        Specifies the login server of the container registry.
        """
        username: pulumi.Input[str]
        """
        Specifies the username of the container registry.
        """
elif False:
    SpringCloudServiceContainerRegistryArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudServiceContainerRegistryArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 password: pulumi.Input[str],
                 server: pulumi.Input[str],
                 username: pulumi.Input[str]):
        """
        :param pulumi.Input[str] name: Specifies the name of the container registry.
        :param pulumi.Input[str] password: Specifies the password of the container registry.
        :param pulumi.Input[str] server: Specifies the login server of the container registry.
        :param pulumi.Input[str] username: Specifies the username of the container registry.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "server", server)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        Specifies the name of the container registry.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def password(self) -> pulumi.Input[str]:
        """
        Specifies the password of the container registry.
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: pulumi.Input[str]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter
    def server(self) -> pulumi.Input[str]:
        """
        Specifies the login server of the container registry.
        """
        return pulumi.get(self, "server")

    @server.setter
    def server(self, value: pulumi.Input[str]):
        pulumi.set(self, "server", value)

    @property
    @pulumi.getter
    def username(self) -> pulumi.Input[str]:
        """
        Specifies the username of the container registry.
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: pulumi.Input[str]):
        pulumi.set(self, "username", value)


if not MYPY:
    class SpringCloudServiceDefaultBuildServiceArgsDict(TypedDict):
        container_registry_name: NotRequired[pulumi.Input[str]]
        """
        Specifies the name of the container registry used in the default build service.
        """
elif False:
    SpringCloudServiceDefaultBuildServiceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudServiceDefaultBuildServiceArgs:
    def __init__(__self__, *,
                 container_registry_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] container_registry_name: Specifies the name of the container registry used in the default build service.
        """
        if container_registry_name is not None:
            pulumi.set(__self__, "container_registry_name", container_registry_name)

    @property
    @pulumi.getter(name="containerRegistryName")
    def container_registry_name(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the name of the container registry used in the default build service.
        """
        return pulumi.get(self, "container_registry_name")

    @container_registry_name.setter
    def container_registry_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "container_registry_name", value)


if not MYPY:
    class SpringCloudServiceMarketplaceArgsDict(TypedDict):
        plan: pulumi.Input[str]
        """
        Specifies the plan ID of the 3rd Party Artifact that is being procured.
        """
        product: pulumi.Input[str]
        """
        Specifies the 3rd Party artifact that is being procured.
        """
        publisher: pulumi.Input[str]
        """
        Specifies the publisher ID of the 3rd Party Artifact that is being procured.
        """
elif False:
    SpringCloudServiceMarketplaceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudServiceMarketplaceArgs:
    def __init__(__self__, *,
                 plan: pulumi.Input[str],
                 product: pulumi.Input[str],
                 publisher: pulumi.Input[str]):
        """
        :param pulumi.Input[str] plan: Specifies the plan ID of the 3rd Party Artifact that is being procured.
        :param pulumi.Input[str] product: Specifies the 3rd Party artifact that is being procured.
        :param pulumi.Input[str] publisher: Specifies the publisher ID of the 3rd Party Artifact that is being procured.
        """
        pulumi.set(__self__, "plan", plan)
        pulumi.set(__self__, "product", product)
        pulumi.set(__self__, "publisher", publisher)

    @property
    @pulumi.getter
    def plan(self) -> pulumi.Input[str]:
        """
        Specifies the plan ID of the 3rd Party Artifact that is being procured.
        """
        return pulumi.get(self, "plan")

    @plan.setter
    def plan(self, value: pulumi.Input[str]):
        pulumi.set(self, "plan", value)

    @property
    @pulumi.getter
    def product(self) -> pulumi.Input[str]:
        """
        Specifies the 3rd Party artifact that is being procured.
        """
        return pulumi.get(self, "product")

    @product.setter
    def product(self, value: pulumi.Input[str]):
        pulumi.set(self, "product", value)

    @property
    @pulumi.getter
    def publisher(self) -> pulumi.Input[str]:
        """
        Specifies the publisher ID of the 3rd Party Artifact that is being procured.
        """
        return pulumi.get(self, "publisher")

    @publisher.setter
    def publisher(self, value: pulumi.Input[str]):
        pulumi.set(self, "publisher", value)


if not MYPY:
    class SpringCloudServiceNetworkArgsDict(TypedDict):
        app_subnet_id: pulumi.Input[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.
        """
        cidr_ranges: pulumi.Input[Sequence[pulumi.Input[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.
        """
        service_runtime_subnet_id: pulumi.Input[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.
        """
        app_network_resource_group: NotRequired[pulumi.Input[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.
        """
        outbound_type: NotRequired[pulumi.Input[str]]
        """
        Specifies the egress traffic type of the Spring Cloud Service. Possible values are `loadBalancer` and `userDefinedRouting`. Defaults to `loadBalancer`. Changing this forces a new resource to be created.
        """
        read_timeout_seconds: NotRequired[pulumi.Input[int]]
        """
        Ingress read time out in seconds.
        """
        service_runtime_network_resource_group: NotRequired[pulumi.Input[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.
        """
elif False:
    SpringCloudServiceNetworkArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudServiceNetworkArgs:
    def __init__(__self__, *,
                 app_subnet_id: pulumi.Input[str],
                 cidr_ranges: pulumi.Input[Sequence[pulumi.Input[str]]],
                 service_runtime_subnet_id: pulumi.Input[str],
                 app_network_resource_group: Optional[pulumi.Input[str]] = None,
                 outbound_type: Optional[pulumi.Input[str]] = None,
                 read_timeout_seconds: Optional[pulumi.Input[int]] = None,
                 service_runtime_network_resource_group: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[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 pulumi.Input[Sequence[pulumi.Input[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 pulumi.Input[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 pulumi.Input[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 pulumi.Input[str] outbound_type: Specifies the egress traffic type of the Spring Cloud Service. Possible values are `loadBalancer` and `userDefinedRouting`. Defaults to `loadBalancer`. Changing this forces a new resource to be created.
        :param pulumi.Input[int] read_timeout_seconds: Ingress read time out in seconds.
        :param pulumi.Input[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 outbound_type is not None:
            pulumi.set(__self__, "outbound_type", outbound_type)
        if read_timeout_seconds is not None:
            pulumi.set(__self__, "read_timeout_seconds", read_timeout_seconds)
        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) -> pulumi.Input[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")

    @app_subnet_id.setter
    def app_subnet_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "app_subnet_id", value)

    @property
    @pulumi.getter(name="cidrRanges")
    def cidr_ranges(self) -> pulumi.Input[Sequence[pulumi.Input[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")

    @cidr_ranges.setter
    def cidr_ranges(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "cidr_ranges", value)

    @property
    @pulumi.getter(name="serviceRuntimeSubnetId")
    def service_runtime_subnet_id(self) -> pulumi.Input[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")

    @service_runtime_subnet_id.setter
    def service_runtime_subnet_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "service_runtime_subnet_id", value)

    @property
    @pulumi.getter(name="appNetworkResourceGroup")
    def app_network_resource_group(self) -> Optional[pulumi.Input[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")

    @app_network_resource_group.setter
    def app_network_resource_group(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "app_network_resource_group", value)

    @property
    @pulumi.getter(name="outboundType")
    def outbound_type(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the egress traffic type of the Spring Cloud Service. Possible values are `loadBalancer` and `userDefinedRouting`. Defaults to `loadBalancer`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "outbound_type")

    @outbound_type.setter
    def outbound_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "outbound_type", value)

    @property
    @pulumi.getter(name="readTimeoutSeconds")
    def read_timeout_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Ingress read time out in seconds.
        """
        return pulumi.get(self, "read_timeout_seconds")

    @read_timeout_seconds.setter
    def read_timeout_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "read_timeout_seconds", value)

    @property
    @pulumi.getter(name="serviceRuntimeNetworkResourceGroup")
    def service_runtime_network_resource_group(self) -> Optional[pulumi.Input[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")

    @service_runtime_network_resource_group.setter
    def service_runtime_network_resource_group(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_runtime_network_resource_group", value)


if not MYPY:
    class SpringCloudServiceRequiredNetworkTrafficRuleArgsDict(TypedDict):
        direction: NotRequired[pulumi.Input[str]]
        """
        The direction of required traffic. Possible values are `Inbound`, `Outbound`.
        """
        fqdns: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        The FQDN list of required traffic.
        """
        ip_addresses: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        The IP list of required traffic.
        """
        port: NotRequired[pulumi.Input[int]]
        """
        The port of required traffic.
        """
        protocol: NotRequired[pulumi.Input[str]]
        """
        The protocol of required traffic.
        """
elif False:
    SpringCloudServiceRequiredNetworkTrafficRuleArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudServiceRequiredNetworkTrafficRuleArgs:
    def __init__(__self__, *,
                 direction: Optional[pulumi.Input[str]] = None,
                 fqdns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ip_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 protocol: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] direction: The direction of required traffic. Possible values are `Inbound`, `Outbound`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] fqdns: The FQDN list of required traffic.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_addresses: The IP list of required traffic.
        :param pulumi.Input[int] port: The port of required traffic.
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        The direction of required traffic. Possible values are `Inbound`, `Outbound`.
        """
        return pulumi.get(self, "direction")

    @direction.setter
    def direction(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "direction", value)

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

    @fqdns.setter
    def fqdns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "fqdns", value)

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

    @ip_addresses.setter
    def ip_addresses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_addresses", value)

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

    @port.setter
    def port(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "port", value)

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

    @protocol.setter
    def protocol(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "protocol", value)


if not MYPY:
    class SpringCloudServiceTraceArgsDict(TypedDict):
        connection_string: NotRequired[pulumi.Input[str]]
        """
        The connection string used for Application Insights.
        """
        sample_rate: NotRequired[pulumi.Input[float]]
        """
        The sampling rate of Application Insights Agent. Must be between `0.0` and `100.0`. Defaults to `10.0`.
        """
elif False:
    SpringCloudServiceTraceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SpringCloudServiceTraceArgs:
    def __init__(__self__, *,
                 connection_string: Optional[pulumi.Input[str]] = None,
                 sample_rate: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[str] connection_string: The connection string used for Application Insights.
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        The connection string used for Application Insights.
        """
        return pulumi.get(self, "connection_string")

    @connection_string.setter
    def connection_string(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "connection_string", value)

    @property
    @pulumi.getter(name="sampleRate")
    def sample_rate(self) -> Optional[pulumi.Input[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")

    @sample_rate.setter
    def sample_rate(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "sample_rate", value)


