# 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 pulumi
import pulumi.runtime
from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
from .. import _utilities

__all__ = [
    'SpringCloudApiPortalSsoArgs',
    'SpringCloudAppCustomPersistentDiskArgs',
    'SpringCloudAppIdentityArgs',
    'SpringCloudAppIngressSettingsArgs',
    'SpringCloudAppPersistentDiskArgs',
    'SpringCloudBuildDeploymentQuotaArgs',
    'SpringCloudBuildPackBindingLaunchArgs',
    'SpringCloudBuilderBuildPackGroupArgs',
    'SpringCloudBuilderStackArgs',
    'SpringCloudConfigurationServiceRepositoryArgs',
    'SpringCloudConnectionAuthenticationArgs',
    'SpringCloudConnectionSecretStoreArgs',
    'SpringCloudContainerDeploymentQuotaArgs',
    'SpringCloudCustomizedAcceleratorGitRepositoryArgs',
    'SpringCloudCustomizedAcceleratorGitRepositoryBasicAuthArgs',
    'SpringCloudCustomizedAcceleratorGitRepositorySshAuthArgs',
    'SpringCloudDevToolPortalSsoArgs',
    'SpringCloudGatewayApiMetadataArgs',
    'SpringCloudGatewayClientAuthorizationArgs',
    'SpringCloudGatewayCorsArgs',
    'SpringCloudGatewayQuotaArgs',
    'SpringCloudGatewayRouteConfigOpenApiArgs',
    'SpringCloudGatewayRouteConfigRouteArgs',
    'SpringCloudGatewaySsoArgs',
    'SpringCloudJavaDeploymentQuotaArgs',
    'SpringCloudServiceConfigServerGitSettingArgs',
    'SpringCloudServiceConfigServerGitSettingHttpBasicAuthArgs',
    'SpringCloudServiceConfigServerGitSettingRepositoryArgs',
    'SpringCloudServiceConfigServerGitSettingRepositoryHttpBasicAuthArgs',
    'SpringCloudServiceConfigServerGitSettingRepositorySshAuthArgs',
    'SpringCloudServiceConfigServerGitSettingSshAuthArgs',
    'SpringCloudServiceContainerRegistryArgs',
    'SpringCloudServiceDefaultBuildServiceArgs',
    'SpringCloudServiceMarketplaceArgs',
    'SpringCloudServiceNetworkArgs',
    'SpringCloudServiceRequiredNetworkTrafficRuleArgs',
    'SpringCloudServiceTraceArgs',
]

@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.
        """
        SpringCloudApiPortalSsoArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            client_id=client_id,
            client_secret=client_secret,
            issuer_uri=issuer_uri,
            scopes=scopes,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             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,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if client_id is None and 'clientId' in kwargs:
            client_id = kwargs['clientId']
        if client_secret is None and 'clientSecret' in kwargs:
            client_secret = kwargs['clientSecret']
        if issuer_uri is None and 'issuerUri' in kwargs:
            issuer_uri = kwargs['issuerUri']

        if client_id is not None:
            _setter("client_id", client_id)
        if client_secret is not None:
            _setter("client_secret", client_secret)
        if issuer_uri is not None:
            _setter("issuer_uri", issuer_uri)
        if scopes is not None:
            _setter("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)


@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.
        """
        SpringCloudAppCustomPersistentDiskArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            mount_path=mount_path,
            share_name=share_name,
            storage_name=storage_name,
            mount_options=mount_options,
            read_only_enabled=read_only_enabled,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             mount_path: Optional[pulumi.Input[str]] = None,
             share_name: Optional[pulumi.Input[str]] = None,
             storage_name: Optional[pulumi.Input[str]] = None,
             mount_options: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             read_only_enabled: Optional[pulumi.Input[bool]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if mount_path is None and 'mountPath' in kwargs:
            mount_path = kwargs['mountPath']
        if mount_path is None:
            raise TypeError("Missing 'mount_path' argument")
        if share_name is None and 'shareName' in kwargs:
            share_name = kwargs['shareName']
        if share_name is None:
            raise TypeError("Missing 'share_name' argument")
        if storage_name is None and 'storageName' in kwargs:
            storage_name = kwargs['storageName']
        if storage_name is None:
            raise TypeError("Missing 'storage_name' argument")
        if mount_options is None and 'mountOptions' in kwargs:
            mount_options = kwargs['mountOptions']
        if read_only_enabled is None and 'readOnlyEnabled' in kwargs:
            read_only_enabled = kwargs['readOnlyEnabled']

        _setter("mount_path", mount_path)
        _setter("share_name", share_name)
        _setter("storage_name", storage_name)
        if mount_options is not None:
            _setter("mount_options", mount_options)
        if read_only_enabled is not None:
            _setter("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)


@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.
        """
        SpringCloudAppIdentityArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            type=type,
            identity_ids=identity_ids,
            principal_id=principal_id,
            tenant_id=tenant_id,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             type: Optional[pulumi.Input[str]] = None,
             identity_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             principal_id: Optional[pulumi.Input[str]] = None,
             tenant_id: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if type is None:
            raise TypeError("Missing 'type' argument")
        if identity_ids is None and 'identityIds' in kwargs:
            identity_ids = kwargs['identityIds']
        if principal_id is None and 'principalId' in kwargs:
            principal_id = kwargs['principalId']
        if tenant_id is None and 'tenantId' in kwargs:
            tenant_id = kwargs['tenantId']

        _setter("type", type)
        if identity_ids is not None:
            _setter("identity_ids", identity_ids)
        if principal_id is not None:
            _setter("principal_id", principal_id)
        if tenant_id is not None:
            _setter("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)


@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.
        """
        SpringCloudAppIngressSettingsArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            backend_protocol=backend_protocol,
            read_timeout_in_seconds=read_timeout_in_seconds,
            send_timeout_in_seconds=send_timeout_in_seconds,
            session_affinity=session_affinity,
            session_cookie_max_age=session_cookie_max_age,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             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,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if backend_protocol is None and 'backendProtocol' in kwargs:
            backend_protocol = kwargs['backendProtocol']
        if read_timeout_in_seconds is None and 'readTimeoutInSeconds' in kwargs:
            read_timeout_in_seconds = kwargs['readTimeoutInSeconds']
        if send_timeout_in_seconds is None and 'sendTimeoutInSeconds' in kwargs:
            send_timeout_in_seconds = kwargs['sendTimeoutInSeconds']
        if session_affinity is None and 'sessionAffinity' in kwargs:
            session_affinity = kwargs['sessionAffinity']
        if session_cookie_max_age is None and 'sessionCookieMaxAge' in kwargs:
            session_cookie_max_age = kwargs['sessionCookieMaxAge']

        if backend_protocol is not None:
            _setter("backend_protocol", backend_protocol)
        if read_timeout_in_seconds is not None:
            _setter("read_timeout_in_seconds", read_timeout_in_seconds)
        if send_timeout_in_seconds is not None:
            _setter("send_timeout_in_seconds", send_timeout_in_seconds)
        if session_affinity is not None:
            _setter("session_affinity", session_affinity)
        if session_cookie_max_age is not None:
            _setter("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)


@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`.
        """
        SpringCloudAppPersistentDiskArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            size_in_gb=size_in_gb,
            mount_path=mount_path,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             size_in_gb: Optional[pulumi.Input[int]] = None,
             mount_path: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if size_in_gb is None and 'sizeInGb' in kwargs:
            size_in_gb = kwargs['sizeInGb']
        if size_in_gb is None:
            raise TypeError("Missing 'size_in_gb' argument")
        if mount_path is None and 'mountPath' in kwargs:
            mount_path = kwargs['mountPath']

        _setter("size_in_gb", size_in_gb)
        if mount_path is not None:
            _setter("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)


@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.
        """
        SpringCloudBuildDeploymentQuotaArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            cpu=cpu,
            memory=memory,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             cpu: Optional[pulumi.Input[str]] = None,
             memory: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):

        if cpu is not None:
            _setter("cpu", cpu)
        if memory is not None:
            _setter("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)


@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.
        """
        SpringCloudBuildPackBindingLaunchArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            properties=properties,
            secrets=secrets,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             properties: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
             secrets: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):

        if properties is not None:
            _setter("properties", properties)
        if secrets is not None:
            _setter("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)


@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.
        """
        SpringCloudBuilderBuildPackGroupArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            name=name,
            build_pack_ids=build_pack_ids,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             name: Optional[pulumi.Input[str]] = None,
             build_pack_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if name is None:
            raise TypeError("Missing 'name' argument")
        if build_pack_ids is None and 'buildPackIds' in kwargs:
            build_pack_ids = kwargs['buildPackIds']

        _setter("name", name)
        if build_pack_ids is not None:
            _setter("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)


@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
        """
        SpringCloudBuilderStackArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            id=id,
            version=version,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             id: Optional[pulumi.Input[str]] = None,
             version: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if id is None:
            raise TypeError("Missing 'id' argument")
        if version is None:
            raise TypeError("Missing 'version' argument")

        _setter("id", id)
        _setter("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)


@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.
        """
        SpringCloudConfigurationServiceRepositoryArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            label=label,
            name=name,
            patterns=patterns,
            uri=uri,
            ca_certificate_id=ca_certificate_id,
            host_key=host_key,
            host_key_algorithm=host_key_algorithm,
            password=password,
            private_key=private_key,
            search_paths=search_paths,
            strict_host_key_checking=strict_host_key_checking,
            username=username,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             label: Optional[pulumi.Input[str]] = None,
             name: Optional[pulumi.Input[str]] = None,
             patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             uri: Optional[pulumi.Input[str]] = None,
             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,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if label is None:
            raise TypeError("Missing 'label' argument")
        if name is None:
            raise TypeError("Missing 'name' argument")
        if patterns is None:
            raise TypeError("Missing 'patterns' argument")
        if uri is None:
            raise TypeError("Missing 'uri' argument")
        if ca_certificate_id is None and 'caCertificateId' in kwargs:
            ca_certificate_id = kwargs['caCertificateId']
        if host_key is None and 'hostKey' in kwargs:
            host_key = kwargs['hostKey']
        if host_key_algorithm is None and 'hostKeyAlgorithm' in kwargs:
            host_key_algorithm = kwargs['hostKeyAlgorithm']
        if private_key is None and 'privateKey' in kwargs:
            private_key = kwargs['privateKey']
        if search_paths is None and 'searchPaths' in kwargs:
            search_paths = kwargs['searchPaths']
        if strict_host_key_checking is None and 'strictHostKeyChecking' in kwargs:
            strict_host_key_checking = kwargs['strictHostKeyChecking']

        _setter("label", label)
        _setter("name", name)
        _setter("patterns", patterns)
        _setter("uri", uri)
        if ca_certificate_id is not None:
            _setter("ca_certificate_id", ca_certificate_id)
        if host_key is not None:
            _setter("host_key", host_key)
        if host_key_algorithm is not None:
            _setter("host_key_algorithm", host_key_algorithm)
        if password is not None:
            _setter("password", password)
        if private_key is not None:
            _setter("private_key", private_key)
        if search_paths is not None:
            _setter("search_paths", search_paths)
        if strict_host_key_checking is not None:
            _setter("strict_host_key_checking", strict_host_key_checking)
        if username is not None:
            _setter("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)


@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.
        """
        SpringCloudConnectionAuthenticationArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            type=type,
            certificate=certificate,
            client_id=client_id,
            name=name,
            principal_id=principal_id,
            secret=secret,
            subscription_id=subscription_id,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             type: Optional[pulumi.Input[str]] = None,
             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,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if type is None:
            raise TypeError("Missing 'type' argument")
        if client_id is None and 'clientId' in kwargs:
            client_id = kwargs['clientId']
        if principal_id is None and 'principalId' in kwargs:
            principal_id = kwargs['principalId']
        if subscription_id is None and 'subscriptionId' in kwargs:
            subscription_id = kwargs['subscriptionId']

        _setter("type", type)
        if certificate is not None:
            _setter("certificate", certificate)
        if client_id is not None:
            _setter("client_id", client_id)
        if name is not None:
            _setter("name", name)
        if principal_id is not None:
            _setter("principal_id", principal_id)
        if secret is not None:
            _setter("secret", secret)
        if subscription_id is not None:
            _setter("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)


@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.
        """
        SpringCloudConnectionSecretStoreArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            key_vault_id=key_vault_id,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             key_vault_id: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if key_vault_id is None and 'keyVaultId' in kwargs:
            key_vault_id = kwargs['keyVaultId']
        if key_vault_id is None:
            raise TypeError("Missing 'key_vault_id' argument")

        _setter("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)


@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.
        """
        SpringCloudContainerDeploymentQuotaArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            cpu=cpu,
            memory=memory,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             cpu: Optional[pulumi.Input[str]] = None,
             memory: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):

        if cpu is not None:
            _setter("cpu", cpu)
        if memory is not None:
            _setter("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)


@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,
                 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['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.
        """
        SpringCloudCustomizedAcceleratorGitRepositoryArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            url=url,
            basic_auth=basic_auth,
            branch=branch,
            ca_certificate_id=ca_certificate_id,
            commit=commit,
            git_tag=git_tag,
            interval_in_seconds=interval_in_seconds,
            ssh_auth=ssh_auth,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             url: Optional[pulumi.Input[str]] = None,
             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,
             ssh_auth: Optional[pulumi.Input['SpringCloudCustomizedAcceleratorGitRepositorySshAuthArgs']] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if url is None:
            raise TypeError("Missing 'url' argument")
        if basic_auth is None and 'basicAuth' in kwargs:
            basic_auth = kwargs['basicAuth']
        if ca_certificate_id is None and 'caCertificateId' in kwargs:
            ca_certificate_id = kwargs['caCertificateId']
        if git_tag is None and 'gitTag' in kwargs:
            git_tag = kwargs['gitTag']
        if interval_in_seconds is None and 'intervalInSeconds' in kwargs:
            interval_in_seconds = kwargs['intervalInSeconds']
        if ssh_auth is None and 'sshAuth' in kwargs:
            ssh_auth = kwargs['sshAuth']

        _setter("url", url)
        if basic_auth is not None:
            _setter("basic_auth", basic_auth)
        if branch is not None:
            _setter("branch", branch)
        if ca_certificate_id is not None:
            _setter("ca_certificate_id", ca_certificate_id)
        if commit is not None:
            _setter("commit", commit)
        if git_tag is not None:
            _setter("git_tag", git_tag)
        if interval_in_seconds is not None:
            _setter("interval_in_seconds", interval_in_seconds)
        if ssh_auth is not None:
            _setter("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(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)


@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.
        """
        SpringCloudCustomizedAcceleratorGitRepositoryBasicAuthArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            password=password,
            username=username,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             password: Optional[pulumi.Input[str]] = None,
             username: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if password is None:
            raise TypeError("Missing 'password' argument")
        if username is None:
            raise TypeError("Missing 'username' argument")

        _setter("password", password)
        _setter("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)


@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.
        """
        SpringCloudCustomizedAcceleratorGitRepositorySshAuthArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            private_key=private_key,
            host_key=host_key,
            host_key_algorithm=host_key_algorithm,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             private_key: Optional[pulumi.Input[str]] = None,
             host_key: Optional[pulumi.Input[str]] = None,
             host_key_algorithm: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if private_key is None and 'privateKey' in kwargs:
            private_key = kwargs['privateKey']
        if private_key is None:
            raise TypeError("Missing 'private_key' argument")
        if host_key is None and 'hostKey' in kwargs:
            host_key = kwargs['hostKey']
        if host_key_algorithm is None and 'hostKeyAlgorithm' in kwargs:
            host_key_algorithm = kwargs['hostKeyAlgorithm']

        _setter("private_key", private_key)
        if host_key is not None:
            _setter("host_key", host_key)
        if host_key_algorithm is not None:
            _setter("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)


@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.
        """
        SpringCloudDevToolPortalSsoArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            client_id=client_id,
            client_secret=client_secret,
            metadata_url=metadata_url,
            scopes=scopes,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             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,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if client_id is None and 'clientId' in kwargs:
            client_id = kwargs['clientId']
        if client_secret is None and 'clientSecret' in kwargs:
            client_secret = kwargs['clientSecret']
        if metadata_url is None and 'metadataUrl' in kwargs:
            metadata_url = kwargs['metadataUrl']

        if client_id is not None:
            _setter("client_id", client_id)
        if client_secret is not None:
            _setter("client_secret", client_secret)
        if metadata_url is not None:
            _setter("metadata_url", metadata_url)
        if scopes is not None:
            _setter("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)


@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.
        """
        SpringCloudGatewayApiMetadataArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            description=description,
            documentation_url=documentation_url,
            server_url=server_url,
            title=title,
            version=version,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             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,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if documentation_url is None and 'documentationUrl' in kwargs:
            documentation_url = kwargs['documentationUrl']
        if server_url is None and 'serverUrl' in kwargs:
            server_url = kwargs['serverUrl']

        if description is not None:
            _setter("description", description)
        if documentation_url is not None:
            _setter("documentation_url", documentation_url)
        if server_url is not None:
            _setter("server_url", server_url)
        if title is not None:
            _setter("title", title)
        if version is not None:
            _setter("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)


@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.
        """
        SpringCloudGatewayClientAuthorizationArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            certificate_ids=certificate_ids,
            verification_enabled=verification_enabled,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             certificate_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             verification_enabled: Optional[pulumi.Input[bool]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if certificate_ids is None and 'certificateIds' in kwargs:
            certificate_ids = kwargs['certificateIds']
        if verification_enabled is None and 'verificationEnabled' in kwargs:
            verification_enabled = kwargs['verificationEnabled']

        if certificate_ids is not None:
            _setter("certificate_ids", certificate_ids)
        if verification_enabled is not None:
            _setter("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)


@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.
        """
        SpringCloudGatewayCorsArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            allowed_headers=allowed_headers,
            allowed_methods=allowed_methods,
            allowed_origin_patterns=allowed_origin_patterns,
            allowed_origins=allowed_origins,
            credentials_allowed=credentials_allowed,
            exposed_headers=exposed_headers,
            max_age_seconds=max_age_seconds,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             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,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if allowed_headers is None and 'allowedHeaders' in kwargs:
            allowed_headers = kwargs['allowedHeaders']
        if allowed_methods is None and 'allowedMethods' in kwargs:
            allowed_methods = kwargs['allowedMethods']
        if allowed_origin_patterns is None and 'allowedOriginPatterns' in kwargs:
            allowed_origin_patterns = kwargs['allowedOriginPatterns']
        if allowed_origins is None and 'allowedOrigins' in kwargs:
            allowed_origins = kwargs['allowedOrigins']
        if credentials_allowed is None and 'credentialsAllowed' in kwargs:
            credentials_allowed = kwargs['credentialsAllowed']
        if exposed_headers is None and 'exposedHeaders' in kwargs:
            exposed_headers = kwargs['exposedHeaders']
        if max_age_seconds is None and 'maxAgeSeconds' in kwargs:
            max_age_seconds = kwargs['maxAgeSeconds']

        if allowed_headers is not None:
            _setter("allowed_headers", allowed_headers)
        if allowed_methods is not None:
            _setter("allowed_methods", allowed_methods)
        if allowed_origin_patterns is not None:
            _setter("allowed_origin_patterns", allowed_origin_patterns)
        if allowed_origins is not None:
            _setter("allowed_origins", allowed_origins)
        if credentials_allowed is not None:
            _setter("credentials_allowed", credentials_allowed)
        if exposed_headers is not None:
            _setter("exposed_headers", exposed_headers)
        if max_age_seconds is not None:
            _setter("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)


@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 `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.
        """
        SpringCloudGatewayQuotaArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            cpu=cpu,
            memory=memory,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             cpu: Optional[pulumi.Input[str]] = None,
             memory: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):

        if cpu is not None:
            _setter("cpu", cpu)
        if memory is not None:
            _setter("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)


@pulumi.input_type
class SpringCloudGatewayRouteConfigOpenApiArgs:
    def __init__(__self__, *,
                 uri: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] uri: The URI of OpenAPI specification.
        """
        SpringCloudGatewayRouteConfigOpenApiArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            uri=uri,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             uri: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):

        if uri is not None:
            _setter("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)


@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`.
        """
        SpringCloudGatewayRouteConfigRouteArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            order=order,
            classification_tags=classification_tags,
            description=description,
            filters=filters,
            predicates=predicates,
            sso_validation_enabled=sso_validation_enabled,
            title=title,
            token_relay=token_relay,
            uri=uri,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             order: Optional[pulumi.Input[int]] = None,
             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,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if order is None:
            raise TypeError("Missing 'order' argument")
        if classification_tags is None and 'classificationTags' in kwargs:
            classification_tags = kwargs['classificationTags']
        if sso_validation_enabled is None and 'ssoValidationEnabled' in kwargs:
            sso_validation_enabled = kwargs['ssoValidationEnabled']
        if token_relay is None and 'tokenRelay' in kwargs:
            token_relay = kwargs['tokenRelay']

        _setter("order", order)
        if classification_tags is not None:
            _setter("classification_tags", classification_tags)
        if description is not None:
            _setter("description", description)
        if filters is not None:
            _setter("filters", filters)
        if predicates is not None:
            _setter("predicates", predicates)
        if sso_validation_enabled is not None:
            _setter("sso_validation_enabled", sso_validation_enabled)
        if title is not None:
            _setter("title", title)
        if token_relay is not None:
            _setter("token_relay", token_relay)
        if uri is not None:
            _setter("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)


@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.
        """
        SpringCloudGatewaySsoArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            client_id=client_id,
            client_secret=client_secret,
            issuer_uri=issuer_uri,
            scopes=scopes,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             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,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if client_id is None and 'clientId' in kwargs:
            client_id = kwargs['clientId']
        if client_secret is None and 'clientSecret' in kwargs:
            client_secret = kwargs['clientSecret']
        if issuer_uri is None and 'issuerUri' in kwargs:
            issuer_uri = kwargs['issuerUri']

        if client_id is not None:
            _setter("client_id", client_id)
        if client_secret is not None:
            _setter("client_secret", client_secret)
        if issuer_uri is not None:
            _setter("issuer_uri", issuer_uri)
        if scopes is not None:
            _setter("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)


@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.
        """
        SpringCloudJavaDeploymentQuotaArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            cpu=cpu,
            memory=memory,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             cpu: Optional[pulumi.Input[str]] = None,
             memory: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):

        if cpu is not None:
            _setter("cpu", cpu)
        if memory is not None:
            _setter("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)


@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.
        """
        SpringCloudServiceConfigServerGitSettingArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            uri=uri,
            http_basic_auth=http_basic_auth,
            label=label,
            repositories=repositories,
            search_paths=search_paths,
            ssh_auth=ssh_auth,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             uri: Optional[pulumi.Input[str]] = None,
             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,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if uri is None:
            raise TypeError("Missing 'uri' argument")
        if http_basic_auth is None and 'httpBasicAuth' in kwargs:
            http_basic_auth = kwargs['httpBasicAuth']
        if search_paths is None and 'searchPaths' in kwargs:
            search_paths = kwargs['searchPaths']
        if ssh_auth is None and 'sshAuth' in kwargs:
            ssh_auth = kwargs['sshAuth']

        _setter("uri", uri)
        if http_basic_auth is not None:
            _setter("http_basic_auth", http_basic_auth)
        if label is not None:
            _setter("label", label)
        if repositories is not None:
            _setter("repositories", repositories)
        if search_paths is not None:
            _setter("search_paths", search_paths)
        if ssh_auth is not None:
            _setter("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)


@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.
        """
        SpringCloudServiceConfigServerGitSettingHttpBasicAuthArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            password=password,
            username=username,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             password: Optional[pulumi.Input[str]] = None,
             username: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if password is None:
            raise TypeError("Missing 'password' argument")
        if username is None:
            raise TypeError("Missing 'username' argument")

        _setter("password", password)
        _setter("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)


@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.
        """
        SpringCloudServiceConfigServerGitSettingRepositoryArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            name=name,
            uri=uri,
            http_basic_auth=http_basic_auth,
            label=label,
            patterns=patterns,
            search_paths=search_paths,
            ssh_auth=ssh_auth,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             name: Optional[pulumi.Input[str]] = None,
             uri: Optional[pulumi.Input[str]] = None,
             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,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if name is None:
            raise TypeError("Missing 'name' argument")
        if uri is None:
            raise TypeError("Missing 'uri' argument")
        if http_basic_auth is None and 'httpBasicAuth' in kwargs:
            http_basic_auth = kwargs['httpBasicAuth']
        if search_paths is None and 'searchPaths' in kwargs:
            search_paths = kwargs['searchPaths']
        if ssh_auth is None and 'sshAuth' in kwargs:
            ssh_auth = kwargs['sshAuth']

        _setter("name", name)
        _setter("uri", uri)
        if http_basic_auth is not None:
            _setter("http_basic_auth", http_basic_auth)
        if label is not None:
            _setter("label", label)
        if patterns is not None:
            _setter("patterns", patterns)
        if search_paths is not None:
            _setter("search_paths", search_paths)
        if ssh_auth is not None:
            _setter("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)


@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.
        """
        SpringCloudServiceConfigServerGitSettingRepositoryHttpBasicAuthArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            password=password,
            username=username,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             password: Optional[pulumi.Input[str]] = None,
             username: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if password is None:
            raise TypeError("Missing 'password' argument")
        if username is None:
            raise TypeError("Missing 'username' argument")

        _setter("password", password)
        _setter("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)


@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`.
        """
        SpringCloudServiceConfigServerGitSettingRepositorySshAuthArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            private_key=private_key,
            host_key=host_key,
            host_key_algorithm=host_key_algorithm,
            strict_host_key_checking_enabled=strict_host_key_checking_enabled,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             private_key: Optional[pulumi.Input[str]] = None,
             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,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if private_key is None and 'privateKey' in kwargs:
            private_key = kwargs['privateKey']
        if private_key is None:
            raise TypeError("Missing 'private_key' argument")
        if host_key is None and 'hostKey' in kwargs:
            host_key = kwargs['hostKey']
        if host_key_algorithm is None and 'hostKeyAlgorithm' in kwargs:
            host_key_algorithm = kwargs['hostKeyAlgorithm']
        if strict_host_key_checking_enabled is None and 'strictHostKeyCheckingEnabled' in kwargs:
            strict_host_key_checking_enabled = kwargs['strictHostKeyCheckingEnabled']

        _setter("private_key", private_key)
        if host_key is not None:
            _setter("host_key", host_key)
        if host_key_algorithm is not None:
            _setter("host_key_algorithm", host_key_algorithm)
        if strict_host_key_checking_enabled is not None:
            _setter("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)


@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`.
        """
        SpringCloudServiceConfigServerGitSettingSshAuthArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            private_key=private_key,
            host_key=host_key,
            host_key_algorithm=host_key_algorithm,
            strict_host_key_checking_enabled=strict_host_key_checking_enabled,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             private_key: Optional[pulumi.Input[str]] = None,
             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,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if private_key is None and 'privateKey' in kwargs:
            private_key = kwargs['privateKey']
        if private_key is None:
            raise TypeError("Missing 'private_key' argument")
        if host_key is None and 'hostKey' in kwargs:
            host_key = kwargs['hostKey']
        if host_key_algorithm is None and 'hostKeyAlgorithm' in kwargs:
            host_key_algorithm = kwargs['hostKeyAlgorithm']
        if strict_host_key_checking_enabled is None and 'strictHostKeyCheckingEnabled' in kwargs:
            strict_host_key_checking_enabled = kwargs['strictHostKeyCheckingEnabled']

        _setter("private_key", private_key)
        if host_key is not None:
            _setter("host_key", host_key)
        if host_key_algorithm is not None:
            _setter("host_key_algorithm", host_key_algorithm)
        if strict_host_key_checking_enabled is not None:
            _setter("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)


@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.
        """
        SpringCloudServiceContainerRegistryArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            name=name,
            password=password,
            server=server,
            username=username,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             name: Optional[pulumi.Input[str]] = None,
             password: Optional[pulumi.Input[str]] = None,
             server: Optional[pulumi.Input[str]] = None,
             username: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if name is None:
            raise TypeError("Missing 'name' argument")
        if password is None:
            raise TypeError("Missing 'password' argument")
        if server is None:
            raise TypeError("Missing 'server' argument")
        if username is None:
            raise TypeError("Missing 'username' argument")

        _setter("name", name)
        _setter("password", password)
        _setter("server", server)
        _setter("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)


@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.
        """
        SpringCloudServiceDefaultBuildServiceArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            container_registry_name=container_registry_name,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             container_registry_name: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if container_registry_name is None and 'containerRegistryName' in kwargs:
            container_registry_name = kwargs['containerRegistryName']

        if container_registry_name is not None:
            _setter("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)


@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.
        """
        SpringCloudServiceMarketplaceArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            plan=plan,
            product=product,
            publisher=publisher,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             plan: Optional[pulumi.Input[str]] = None,
             product: Optional[pulumi.Input[str]] = None,
             publisher: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if plan is None:
            raise TypeError("Missing 'plan' argument")
        if product is None:
            raise TypeError("Missing 'product' argument")
        if publisher is None:
            raise TypeError("Missing 'publisher' argument")

        _setter("plan", plan)
        _setter("product", product)
        _setter("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)


@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.
        """
        SpringCloudServiceNetworkArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            app_subnet_id=app_subnet_id,
            cidr_ranges=cidr_ranges,
            service_runtime_subnet_id=service_runtime_subnet_id,
            app_network_resource_group=app_network_resource_group,
            outbound_type=outbound_type,
            read_timeout_seconds=read_timeout_seconds,
            service_runtime_network_resource_group=service_runtime_network_resource_group,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             app_subnet_id: Optional[pulumi.Input[str]] = None,
             cidr_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             service_runtime_subnet_id: Optional[pulumi.Input[str]] = None,
             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,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if app_subnet_id is None and 'appSubnetId' in kwargs:
            app_subnet_id = kwargs['appSubnetId']
        if app_subnet_id is None:
            raise TypeError("Missing 'app_subnet_id' argument")
        if cidr_ranges is None and 'cidrRanges' in kwargs:
            cidr_ranges = kwargs['cidrRanges']
        if cidr_ranges is None:
            raise TypeError("Missing 'cidr_ranges' argument")
        if service_runtime_subnet_id is None and 'serviceRuntimeSubnetId' in kwargs:
            service_runtime_subnet_id = kwargs['serviceRuntimeSubnetId']
        if service_runtime_subnet_id is None:
            raise TypeError("Missing 'service_runtime_subnet_id' argument")
        if app_network_resource_group is None and 'appNetworkResourceGroup' in kwargs:
            app_network_resource_group = kwargs['appNetworkResourceGroup']
        if outbound_type is None and 'outboundType' in kwargs:
            outbound_type = kwargs['outboundType']
        if read_timeout_seconds is None and 'readTimeoutSeconds' in kwargs:
            read_timeout_seconds = kwargs['readTimeoutSeconds']
        if service_runtime_network_resource_group is None and 'serviceRuntimeNetworkResourceGroup' in kwargs:
            service_runtime_network_resource_group = kwargs['serviceRuntimeNetworkResourceGroup']

        _setter("app_subnet_id", app_subnet_id)
        _setter("cidr_ranges", cidr_ranges)
        _setter("service_runtime_subnet_id", service_runtime_subnet_id)
        if app_network_resource_group is not None:
            _setter("app_network_resource_group", app_network_resource_group)
        if outbound_type is not None:
            _setter("outbound_type", outbound_type)
        if read_timeout_seconds is not None:
            _setter("read_timeout_seconds", read_timeout_seconds)
        if service_runtime_network_resource_group is not None:
            _setter("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)


@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.
        """
        SpringCloudServiceRequiredNetworkTrafficRuleArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            direction=direction,
            fqdns=fqdns,
            ip_addresses=ip_addresses,
            port=port,
            protocol=protocol,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             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,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if ip_addresses is None and 'ipAddresses' in kwargs:
            ip_addresses = kwargs['ipAddresses']

        if direction is not None:
            _setter("direction", direction)
        if fqdns is not None:
            _setter("fqdns", fqdns)
        if ip_addresses is not None:
            _setter("ip_addresses", ip_addresses)
        if port is not None:
            _setter("port", port)
        if protocol is not None:
            _setter("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)


@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`.
        """
        SpringCloudServiceTraceArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            connection_string=connection_string,
            sample_rate=sample_rate,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             connection_string: Optional[pulumi.Input[str]] = None,
             sample_rate: Optional[pulumi.Input[float]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if connection_string is None and 'connectionString' in kwargs:
            connection_string = kwargs['connectionString']
        if sample_rate is None and 'sampleRate' in kwargs:
            sample_rate = kwargs['sampleRate']

        if connection_string is not None:
            _setter("connection_string", connection_string)
        if sample_rate is not None:
            _setter("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)


