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

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

__all__ = [
    'GatewayRouteSpec',
    'GatewayRouteSpecGrpcRoute',
    'GatewayRouteSpecGrpcRouteAction',
    'GatewayRouteSpecGrpcRouteActionTarget',
    'GatewayRouteSpecGrpcRouteActionTargetVirtualService',
    'GatewayRouteSpecGrpcRouteMatch',
    'GatewayRouteSpecHttp2Route',
    'GatewayRouteSpecHttp2RouteAction',
    'GatewayRouteSpecHttp2RouteActionTarget',
    'GatewayRouteSpecHttp2RouteActionTargetVirtualService',
    'GatewayRouteSpecHttp2RouteMatch',
    'GatewayRouteSpecHttpRoute',
    'GatewayRouteSpecHttpRouteAction',
    'GatewayRouteSpecHttpRouteActionTarget',
    'GatewayRouteSpecHttpRouteActionTargetVirtualService',
    'GatewayRouteSpecHttpRouteMatch',
    'MeshSpec',
    'MeshSpecEgressFilter',
    'RouteSpec',
    'RouteSpecGrpcRoute',
    'RouteSpecGrpcRouteAction',
    'RouteSpecGrpcRouteActionWeightedTarget',
    'RouteSpecGrpcRouteMatch',
    'RouteSpecGrpcRouteMatchMetadata',
    'RouteSpecGrpcRouteMatchMetadataMatch',
    'RouteSpecGrpcRouteMatchMetadataMatchRange',
    'RouteSpecGrpcRouteRetryPolicy',
    'RouteSpecGrpcRouteRetryPolicyPerRetryTimeout',
    'RouteSpecGrpcRouteTimeout',
    'RouteSpecGrpcRouteTimeoutIdle',
    'RouteSpecGrpcRouteTimeoutPerRequest',
    'RouteSpecHttp2Route',
    'RouteSpecHttp2RouteAction',
    'RouteSpecHttp2RouteActionWeightedTarget',
    'RouteSpecHttp2RouteMatch',
    'RouteSpecHttp2RouteMatchHeader',
    'RouteSpecHttp2RouteMatchHeaderMatch',
    'RouteSpecHttp2RouteMatchHeaderMatchRange',
    'RouteSpecHttp2RouteRetryPolicy',
    'RouteSpecHttp2RouteRetryPolicyPerRetryTimeout',
    'RouteSpecHttp2RouteTimeout',
    'RouteSpecHttp2RouteTimeoutIdle',
    'RouteSpecHttp2RouteTimeoutPerRequest',
    'RouteSpecHttpRoute',
    'RouteSpecHttpRouteAction',
    'RouteSpecHttpRouteActionWeightedTarget',
    'RouteSpecHttpRouteMatch',
    'RouteSpecHttpRouteMatchHeader',
    'RouteSpecHttpRouteMatchHeaderMatch',
    'RouteSpecHttpRouteMatchHeaderMatchRange',
    'RouteSpecHttpRouteRetryPolicy',
    'RouteSpecHttpRouteRetryPolicyPerRetryTimeout',
    'RouteSpecHttpRouteTimeout',
    'RouteSpecHttpRouteTimeoutIdle',
    'RouteSpecHttpRouteTimeoutPerRequest',
    'RouteSpecTcpRoute',
    'RouteSpecTcpRouteAction',
    'RouteSpecTcpRouteActionWeightedTarget',
    'RouteSpecTcpRouteTimeout',
    'RouteSpecTcpRouteTimeoutIdle',
    'VirtualGatewaySpec',
    'VirtualGatewaySpecBackendDefaults',
    'VirtualGatewaySpecBackendDefaultsClientPolicy',
    'VirtualGatewaySpecBackendDefaultsClientPolicyTls',
    'VirtualGatewaySpecBackendDefaultsClientPolicyTlsCertificate',
    'VirtualGatewaySpecBackendDefaultsClientPolicyTlsCertificateFile',
    'VirtualGatewaySpecBackendDefaultsClientPolicyTlsCertificateSds',
    'VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidation',
    'VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNames',
    'VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatch',
    'VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrust',
    'VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustAcm',
    'VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustFile',
    'VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustSds',
    'VirtualGatewaySpecListener',
    'VirtualGatewaySpecListenerConnectionPool',
    'VirtualGatewaySpecListenerConnectionPoolGrpc',
    'VirtualGatewaySpecListenerConnectionPoolHttp2',
    'VirtualGatewaySpecListenerConnectionPoolHttp',
    'VirtualGatewaySpecListenerHealthCheck',
    'VirtualGatewaySpecListenerPortMapping',
    'VirtualGatewaySpecListenerTls',
    'VirtualGatewaySpecListenerTlsCertificate',
    'VirtualGatewaySpecListenerTlsCertificateAcm',
    'VirtualGatewaySpecListenerTlsCertificateFile',
    'VirtualGatewaySpecListenerTlsCertificateSds',
    'VirtualGatewaySpecListenerTlsValidation',
    'VirtualGatewaySpecListenerTlsValidationSubjectAlternativeNames',
    'VirtualGatewaySpecListenerTlsValidationSubjectAlternativeNamesMatch',
    'VirtualGatewaySpecListenerTlsValidationTrust',
    'VirtualGatewaySpecListenerTlsValidationTrustFile',
    'VirtualGatewaySpecListenerTlsValidationTrustSds',
    'VirtualGatewaySpecLogging',
    'VirtualGatewaySpecLoggingAccessLog',
    'VirtualGatewaySpecLoggingAccessLogFile',
    'VirtualNodeSpec',
    'VirtualNodeSpecBackend',
    'VirtualNodeSpecBackendDefaults',
    'VirtualNodeSpecBackendDefaultsClientPolicy',
    'VirtualNodeSpecBackendDefaultsClientPolicyTls',
    'VirtualNodeSpecBackendDefaultsClientPolicyTlsCertificate',
    'VirtualNodeSpecBackendDefaultsClientPolicyTlsCertificateFile',
    'VirtualNodeSpecBackendDefaultsClientPolicyTlsCertificateSds',
    'VirtualNodeSpecBackendDefaultsClientPolicyTlsValidation',
    'VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNames',
    'VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatch',
    'VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrust',
    'VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustAcm',
    'VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustFile',
    'VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustSds',
    'VirtualNodeSpecBackendVirtualService',
    'VirtualNodeSpecBackendVirtualServiceClientPolicy',
    'VirtualNodeSpecBackendVirtualServiceClientPolicyTls',
    'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsCertificate',
    'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsCertificateFile',
    'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsCertificateSds',
    'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidation',
    'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationSubjectAlternativeNames',
    'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatch',
    'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrust',
    'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustAcm',
    'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustFile',
    'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustSds',
    'VirtualNodeSpecListener',
    'VirtualNodeSpecListenerConnectionPool',
    'VirtualNodeSpecListenerConnectionPoolGrpc',
    'VirtualNodeSpecListenerConnectionPoolHttp2',
    'VirtualNodeSpecListenerConnectionPoolHttp',
    'VirtualNodeSpecListenerConnectionPoolTcp',
    'VirtualNodeSpecListenerHealthCheck',
    'VirtualNodeSpecListenerOutlierDetection',
    'VirtualNodeSpecListenerOutlierDetectionBaseEjectionDuration',
    'VirtualNodeSpecListenerOutlierDetectionInterval',
    'VirtualNodeSpecListenerPortMapping',
    'VirtualNodeSpecListenerTimeout',
    'VirtualNodeSpecListenerTimeoutGrpc',
    'VirtualNodeSpecListenerTimeoutGrpcIdle',
    'VirtualNodeSpecListenerTimeoutGrpcPerRequest',
    'VirtualNodeSpecListenerTimeoutHttp2',
    'VirtualNodeSpecListenerTimeoutHttp2Idle',
    'VirtualNodeSpecListenerTimeoutHttp2PerRequest',
    'VirtualNodeSpecListenerTimeoutHttp',
    'VirtualNodeSpecListenerTimeoutHttpIdle',
    'VirtualNodeSpecListenerTimeoutHttpPerRequest',
    'VirtualNodeSpecListenerTimeoutTcp',
    'VirtualNodeSpecListenerTimeoutTcpIdle',
    'VirtualNodeSpecListenerTls',
    'VirtualNodeSpecListenerTlsCertificate',
    'VirtualNodeSpecListenerTlsCertificateAcm',
    'VirtualNodeSpecListenerTlsCertificateFile',
    'VirtualNodeSpecListenerTlsCertificateSds',
    'VirtualNodeSpecListenerTlsValidation',
    'VirtualNodeSpecListenerTlsValidationSubjectAlternativeNames',
    'VirtualNodeSpecListenerTlsValidationSubjectAlternativeNamesMatch',
    'VirtualNodeSpecListenerTlsValidationTrust',
    'VirtualNodeSpecListenerTlsValidationTrustFile',
    'VirtualNodeSpecListenerTlsValidationTrustSds',
    'VirtualNodeSpecLogging',
    'VirtualNodeSpecLoggingAccessLog',
    'VirtualNodeSpecLoggingAccessLogFile',
    'VirtualNodeSpecServiceDiscovery',
    'VirtualNodeSpecServiceDiscoveryAwsCloudMap',
    'VirtualNodeSpecServiceDiscoveryDns',
    'VirtualRouterSpec',
    'VirtualRouterSpecListener',
    'VirtualRouterSpecListenerPortMapping',
    'VirtualServiceSpec',
    'VirtualServiceSpecProvider',
    'VirtualServiceSpecProviderVirtualNode',
    'VirtualServiceSpecProviderVirtualRouter',
    'GetMeshSpecResult',
    'GetMeshSpecEgressFilterResult',
    'GetVirtualServiceSpecResult',
    'GetVirtualServiceSpecProviderResult',
    'GetVirtualServiceSpecProviderVirtualNodeResult',
    'GetVirtualServiceSpecProviderVirtualRouterResult',
]

@pulumi.output_type
class GatewayRouteSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "grpcRoute":
            suggest = "grpc_route"
        elif key == "http2Route":
            suggest = "http2_route"
        elif key == "httpRoute":
            suggest = "http_route"

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

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

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

    def __init__(__self__, *,
                 grpc_route: Optional['outputs.GatewayRouteSpecGrpcRoute'] = None,
                 http2_route: Optional['outputs.GatewayRouteSpecHttp2Route'] = None,
                 http_route: Optional['outputs.GatewayRouteSpecHttpRoute'] = None):
        """
        :param 'GatewayRouteSpecGrpcRouteArgs' grpc_route: The specification of a gRPC gateway route.
        :param 'GatewayRouteSpecHttp2RouteArgs' http2_route: The specification of an HTTP/2 gateway route.
        :param 'GatewayRouteSpecHttpRouteArgs' http_route: The specification of an HTTP gateway route.
        """
        if grpc_route is not None:
            pulumi.set(__self__, "grpc_route", grpc_route)
        if http2_route is not None:
            pulumi.set(__self__, "http2_route", http2_route)
        if http_route is not None:
            pulumi.set(__self__, "http_route", http_route)

    @property
    @pulumi.getter(name="grpcRoute")
    def grpc_route(self) -> Optional['outputs.GatewayRouteSpecGrpcRoute']:
        """
        The specification of a gRPC gateway route.
        """
        return pulumi.get(self, "grpc_route")

    @property
    @pulumi.getter(name="http2Route")
    def http2_route(self) -> Optional['outputs.GatewayRouteSpecHttp2Route']:
        """
        The specification of an HTTP/2 gateway route.
        """
        return pulumi.get(self, "http2_route")

    @property
    @pulumi.getter(name="httpRoute")
    def http_route(self) -> Optional['outputs.GatewayRouteSpecHttpRoute']:
        """
        The specification of an HTTP gateway route.
        """
        return pulumi.get(self, "http_route")


@pulumi.output_type
class GatewayRouteSpecGrpcRoute(dict):
    def __init__(__self__, *,
                 action: 'outputs.GatewayRouteSpecGrpcRouteAction',
                 match: 'outputs.GatewayRouteSpecGrpcRouteMatch'):
        """
        :param 'GatewayRouteSpecGrpcRouteActionArgs' action: The action to take if a match is determined.
        :param 'GatewayRouteSpecGrpcRouteMatchArgs' match: The criteria for determining a request match.
        """
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def action(self) -> 'outputs.GatewayRouteSpecGrpcRouteAction':
        """
        The action to take if a match is determined.
        """
        return pulumi.get(self, "action")

    @property
    @pulumi.getter
    def match(self) -> 'outputs.GatewayRouteSpecGrpcRouteMatch':
        """
        The criteria for determining a request match.
        """
        return pulumi.get(self, "match")


@pulumi.output_type
class GatewayRouteSpecGrpcRouteAction(dict):
    def __init__(__self__, *,
                 target: 'outputs.GatewayRouteSpecGrpcRouteActionTarget'):
        """
        :param 'GatewayRouteSpecGrpcRouteActionTargetArgs' target: The target that traffic is routed to when a request matches the gateway route.
        """
        pulumi.set(__self__, "target", target)

    @property
    @pulumi.getter
    def target(self) -> 'outputs.GatewayRouteSpecGrpcRouteActionTarget':
        """
        The target that traffic is routed to when a request matches the gateway route.
        """
        return pulumi.get(self, "target")


@pulumi.output_type
class GatewayRouteSpecGrpcRouteActionTarget(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "virtualService":
            suggest = "virtual_service"

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

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

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

    def __init__(__self__, *,
                 virtual_service: 'outputs.GatewayRouteSpecGrpcRouteActionTargetVirtualService'):
        """
        :param 'GatewayRouteSpecGrpcRouteActionTargetVirtualServiceArgs' virtual_service: The virtual service gateway route target.
        """
        pulumi.set(__self__, "virtual_service", virtual_service)

    @property
    @pulumi.getter(name="virtualService")
    def virtual_service(self) -> 'outputs.GatewayRouteSpecGrpcRouteActionTargetVirtualService':
        """
        The virtual service gateway route target.
        """
        return pulumi.get(self, "virtual_service")


@pulumi.output_type
class GatewayRouteSpecGrpcRouteActionTargetVirtualService(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "virtualServiceName":
            suggest = "virtual_service_name"

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

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

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

    def __init__(__self__, *,
                 virtual_service_name: str):
        """
        :param str virtual_service_name: The name of the virtual service that traffic is routed to. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "virtual_service_name", virtual_service_name)

    @property
    @pulumi.getter(name="virtualServiceName")
    def virtual_service_name(self) -> str:
        """
        The name of the virtual service that traffic is routed to. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "virtual_service_name")


@pulumi.output_type
class GatewayRouteSpecGrpcRouteMatch(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "serviceName":
            suggest = "service_name"

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

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

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

    def __init__(__self__, *,
                 service_name: str):
        """
        :param str service_name: The fully qualified domain name for the service to match from the request.
        """
        pulumi.set(__self__, "service_name", service_name)

    @property
    @pulumi.getter(name="serviceName")
    def service_name(self) -> str:
        """
        The fully qualified domain name for the service to match from the request.
        """
        return pulumi.get(self, "service_name")


@pulumi.output_type
class GatewayRouteSpecHttp2Route(dict):
    def __init__(__self__, *,
                 action: 'outputs.GatewayRouteSpecHttp2RouteAction',
                 match: 'outputs.GatewayRouteSpecHttp2RouteMatch'):
        """
        :param 'GatewayRouteSpecHttp2RouteActionArgs' action: The action to take if a match is determined.
        :param 'GatewayRouteSpecHttp2RouteMatchArgs' match: The criteria for determining a request match.
        """
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def action(self) -> 'outputs.GatewayRouteSpecHttp2RouteAction':
        """
        The action to take if a match is determined.
        """
        return pulumi.get(self, "action")

    @property
    @pulumi.getter
    def match(self) -> 'outputs.GatewayRouteSpecHttp2RouteMatch':
        """
        The criteria for determining a request match.
        """
        return pulumi.get(self, "match")


@pulumi.output_type
class GatewayRouteSpecHttp2RouteAction(dict):
    def __init__(__self__, *,
                 target: 'outputs.GatewayRouteSpecHttp2RouteActionTarget'):
        """
        :param 'GatewayRouteSpecHttp2RouteActionTargetArgs' target: The target that traffic is routed to when a request matches the gateway route.
        """
        pulumi.set(__self__, "target", target)

    @property
    @pulumi.getter
    def target(self) -> 'outputs.GatewayRouteSpecHttp2RouteActionTarget':
        """
        The target that traffic is routed to when a request matches the gateway route.
        """
        return pulumi.get(self, "target")


@pulumi.output_type
class GatewayRouteSpecHttp2RouteActionTarget(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "virtualService":
            suggest = "virtual_service"

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

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

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

    def __init__(__self__, *,
                 virtual_service: 'outputs.GatewayRouteSpecHttp2RouteActionTargetVirtualService'):
        """
        :param 'GatewayRouteSpecHttp2RouteActionTargetVirtualServiceArgs' virtual_service: The virtual service gateway route target.
        """
        pulumi.set(__self__, "virtual_service", virtual_service)

    @property
    @pulumi.getter(name="virtualService")
    def virtual_service(self) -> 'outputs.GatewayRouteSpecHttp2RouteActionTargetVirtualService':
        """
        The virtual service gateway route target.
        """
        return pulumi.get(self, "virtual_service")


@pulumi.output_type
class GatewayRouteSpecHttp2RouteActionTargetVirtualService(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "virtualServiceName":
            suggest = "virtual_service_name"

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

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

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

    def __init__(__self__, *,
                 virtual_service_name: str):
        """
        :param str virtual_service_name: The name of the virtual service that traffic is routed to. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "virtual_service_name", virtual_service_name)

    @property
    @pulumi.getter(name="virtualServiceName")
    def virtual_service_name(self) -> str:
        """
        The name of the virtual service that traffic is routed to. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "virtual_service_name")


@pulumi.output_type
class GatewayRouteSpecHttp2RouteMatch(dict):
    def __init__(__self__, *,
                 prefix: str):
        """
        :param str prefix: Specifies the path to match requests with. This parameter must always start with `/`, which by itself matches all requests to the virtual service name.
        """
        pulumi.set(__self__, "prefix", prefix)

    @property
    @pulumi.getter
    def prefix(self) -> str:
        """
        Specifies the path to match requests with. This parameter must always start with `/`, which by itself matches all requests to the virtual service name.
        """
        return pulumi.get(self, "prefix")


@pulumi.output_type
class GatewayRouteSpecHttpRoute(dict):
    def __init__(__self__, *,
                 action: 'outputs.GatewayRouteSpecHttpRouteAction',
                 match: 'outputs.GatewayRouteSpecHttpRouteMatch'):
        """
        :param 'GatewayRouteSpecHttpRouteActionArgs' action: The action to take if a match is determined.
        :param 'GatewayRouteSpecHttpRouteMatchArgs' match: The criteria for determining a request match.
        """
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def action(self) -> 'outputs.GatewayRouteSpecHttpRouteAction':
        """
        The action to take if a match is determined.
        """
        return pulumi.get(self, "action")

    @property
    @pulumi.getter
    def match(self) -> 'outputs.GatewayRouteSpecHttpRouteMatch':
        """
        The criteria for determining a request match.
        """
        return pulumi.get(self, "match")


@pulumi.output_type
class GatewayRouteSpecHttpRouteAction(dict):
    def __init__(__self__, *,
                 target: 'outputs.GatewayRouteSpecHttpRouteActionTarget'):
        """
        :param 'GatewayRouteSpecHttpRouteActionTargetArgs' target: The target that traffic is routed to when a request matches the gateway route.
        """
        pulumi.set(__self__, "target", target)

    @property
    @pulumi.getter
    def target(self) -> 'outputs.GatewayRouteSpecHttpRouteActionTarget':
        """
        The target that traffic is routed to when a request matches the gateway route.
        """
        return pulumi.get(self, "target")


@pulumi.output_type
class GatewayRouteSpecHttpRouteActionTarget(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "virtualService":
            suggest = "virtual_service"

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

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

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

    def __init__(__self__, *,
                 virtual_service: 'outputs.GatewayRouteSpecHttpRouteActionTargetVirtualService'):
        """
        :param 'GatewayRouteSpecHttpRouteActionTargetVirtualServiceArgs' virtual_service: The virtual service gateway route target.
        """
        pulumi.set(__self__, "virtual_service", virtual_service)

    @property
    @pulumi.getter(name="virtualService")
    def virtual_service(self) -> 'outputs.GatewayRouteSpecHttpRouteActionTargetVirtualService':
        """
        The virtual service gateway route target.
        """
        return pulumi.get(self, "virtual_service")


@pulumi.output_type
class GatewayRouteSpecHttpRouteActionTargetVirtualService(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "virtualServiceName":
            suggest = "virtual_service_name"

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

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

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

    def __init__(__self__, *,
                 virtual_service_name: str):
        """
        :param str virtual_service_name: The name of the virtual service that traffic is routed to. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "virtual_service_name", virtual_service_name)

    @property
    @pulumi.getter(name="virtualServiceName")
    def virtual_service_name(self) -> str:
        """
        The name of the virtual service that traffic is routed to. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "virtual_service_name")


@pulumi.output_type
class GatewayRouteSpecHttpRouteMatch(dict):
    def __init__(__self__, *,
                 prefix: str):
        """
        :param str prefix: Specifies the path to match requests with. This parameter must always start with `/`, which by itself matches all requests to the virtual service name.
        """
        pulumi.set(__self__, "prefix", prefix)

    @property
    @pulumi.getter
    def prefix(self) -> str:
        """
        Specifies the path to match requests with. This parameter must always start with `/`, which by itself matches all requests to the virtual service name.
        """
        return pulumi.get(self, "prefix")


@pulumi.output_type
class MeshSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "egressFilter":
            suggest = "egress_filter"

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

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

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

    def __init__(__self__, *,
                 egress_filter: Optional['outputs.MeshSpecEgressFilter'] = None):
        """
        :param 'MeshSpecEgressFilterArgs' egress_filter: The egress filter rules for the service mesh.
        """
        if egress_filter is not None:
            pulumi.set(__self__, "egress_filter", egress_filter)

    @property
    @pulumi.getter(name="egressFilter")
    def egress_filter(self) -> Optional['outputs.MeshSpecEgressFilter']:
        """
        The egress filter rules for the service mesh.
        """
        return pulumi.get(self, "egress_filter")


@pulumi.output_type
class MeshSpecEgressFilter(dict):
    def __init__(__self__, *,
                 type: Optional[str] = None):
        """
        :param str type: The egress filter type. By default, the type is `DROP_ALL`.
               Valid values are `ALLOW_ALL` and `DROP_ALL`.
        """
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        The egress filter type. By default, the type is `DROP_ALL`.
        Valid values are `ALLOW_ALL` and `DROP_ALL`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class RouteSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "grpcRoute":
            suggest = "grpc_route"
        elif key == "http2Route":
            suggest = "http2_route"
        elif key == "httpRoute":
            suggest = "http_route"
        elif key == "tcpRoute":
            suggest = "tcp_route"

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

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

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

    def __init__(__self__, *,
                 grpc_route: Optional['outputs.RouteSpecGrpcRoute'] = None,
                 http2_route: Optional['outputs.RouteSpecHttp2Route'] = None,
                 http_route: Optional['outputs.RouteSpecHttpRoute'] = None,
                 priority: Optional[int] = None,
                 tcp_route: Optional['outputs.RouteSpecTcpRoute'] = None):
        """
        :param 'RouteSpecGrpcRouteArgs' grpc_route: The gRPC routing information for the route.
        :param 'RouteSpecHttp2RouteArgs' http2_route: The HTTP/2 routing information for the route.
        :param 'RouteSpecHttpRouteArgs' http_route: The HTTP routing information for the route.
        :param int priority: The priority for the route, between `0` and `1000`.
               Routes are matched based on the specified value, where `0` is the highest priority.
        :param 'RouteSpecTcpRouteArgs' tcp_route: The TCP routing information for the route.
        """
        if grpc_route is not None:
            pulumi.set(__self__, "grpc_route", grpc_route)
        if http2_route is not None:
            pulumi.set(__self__, "http2_route", http2_route)
        if http_route is not None:
            pulumi.set(__self__, "http_route", http_route)
        if priority is not None:
            pulumi.set(__self__, "priority", priority)
        if tcp_route is not None:
            pulumi.set(__self__, "tcp_route", tcp_route)

    @property
    @pulumi.getter(name="grpcRoute")
    def grpc_route(self) -> Optional['outputs.RouteSpecGrpcRoute']:
        """
        The gRPC routing information for the route.
        """
        return pulumi.get(self, "grpc_route")

    @property
    @pulumi.getter(name="http2Route")
    def http2_route(self) -> Optional['outputs.RouteSpecHttp2Route']:
        """
        The HTTP/2 routing information for the route.
        """
        return pulumi.get(self, "http2_route")

    @property
    @pulumi.getter(name="httpRoute")
    def http_route(self) -> Optional['outputs.RouteSpecHttpRoute']:
        """
        The HTTP routing information for the route.
        """
        return pulumi.get(self, "http_route")

    @property
    @pulumi.getter
    def priority(self) -> Optional[int]:
        """
        The priority for the route, between `0` and `1000`.
        Routes are matched based on the specified value, where `0` is the highest priority.
        """
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter(name="tcpRoute")
    def tcp_route(self) -> Optional['outputs.RouteSpecTcpRoute']:
        """
        The TCP routing information for the route.
        """
        return pulumi.get(self, "tcp_route")


@pulumi.output_type
class RouteSpecGrpcRoute(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "retryPolicy":
            suggest = "retry_policy"

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

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

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

    def __init__(__self__, *,
                 action: 'outputs.RouteSpecGrpcRouteAction',
                 match: Optional['outputs.RouteSpecGrpcRouteMatch'] = None,
                 retry_policy: Optional['outputs.RouteSpecGrpcRouteRetryPolicy'] = None,
                 timeout: Optional['outputs.RouteSpecGrpcRouteTimeout'] = None):
        """
        :param 'RouteSpecGrpcRouteActionArgs' action: The action to take if a match is determined.
        :param 'RouteSpecGrpcRouteMatchArgs' match: The criteria for determining an gRPC request match.
        :param 'RouteSpecGrpcRouteRetryPolicyArgs' retry_policy: The retry policy.
        :param 'RouteSpecGrpcRouteTimeoutArgs' timeout: The types of timeouts.
        """
        pulumi.set(__self__, "action", action)
        if match is not None:
            pulumi.set(__self__, "match", match)
        if retry_policy is not None:
            pulumi.set(__self__, "retry_policy", retry_policy)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter
    def action(self) -> 'outputs.RouteSpecGrpcRouteAction':
        """
        The action to take if a match is determined.
        """
        return pulumi.get(self, "action")

    @property
    @pulumi.getter
    def match(self) -> Optional['outputs.RouteSpecGrpcRouteMatch']:
        """
        The criteria for determining an gRPC request match.
        """
        return pulumi.get(self, "match")

    @property
    @pulumi.getter(name="retryPolicy")
    def retry_policy(self) -> Optional['outputs.RouteSpecGrpcRouteRetryPolicy']:
        """
        The retry policy.
        """
        return pulumi.get(self, "retry_policy")

    @property
    @pulumi.getter
    def timeout(self) -> Optional['outputs.RouteSpecGrpcRouteTimeout']:
        """
        The types of timeouts.
        """
        return pulumi.get(self, "timeout")


@pulumi.output_type
class RouteSpecGrpcRouteAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "weightedTargets":
            suggest = "weighted_targets"

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

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

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

    def __init__(__self__, *,
                 weighted_targets: Sequence['outputs.RouteSpecGrpcRouteActionWeightedTarget']):
        """
        :param Sequence['RouteSpecGrpcRouteActionWeightedTargetArgs'] weighted_targets: The targets that traffic is routed to when a request matches the route.
               You can specify one or more targets and their relative weights with which to distribute traffic.
        """
        pulumi.set(__self__, "weighted_targets", weighted_targets)

    @property
    @pulumi.getter(name="weightedTargets")
    def weighted_targets(self) -> Sequence['outputs.RouteSpecGrpcRouteActionWeightedTarget']:
        """
        The targets that traffic is routed to when a request matches the route.
        You can specify one or more targets and their relative weights with which to distribute traffic.
        """
        return pulumi.get(self, "weighted_targets")


@pulumi.output_type
class RouteSpecGrpcRouteActionWeightedTarget(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "virtualNode":
            suggest = "virtual_node"

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

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

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

    def __init__(__self__, *,
                 virtual_node: str,
                 weight: int):
        """
        :param str virtual_node: The virtual node to associate with the weighted target. Must be between 1 and 255 characters in length.
        :param int weight: The relative weight of the weighted target. An integer between 0 and 100.
        """
        pulumi.set(__self__, "virtual_node", virtual_node)
        pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter(name="virtualNode")
    def virtual_node(self) -> str:
        """
        The virtual node to associate with the weighted target. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "virtual_node")

    @property
    @pulumi.getter
    def weight(self) -> int:
        """
        The relative weight of the weighted target. An integer between 0 and 100.
        """
        return pulumi.get(self, "weight")


@pulumi.output_type
class RouteSpecGrpcRouteMatch(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "methodName":
            suggest = "method_name"
        elif key == "serviceName":
            suggest = "service_name"

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

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

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

    def __init__(__self__, *,
                 metadatas: Optional[Sequence['outputs.RouteSpecGrpcRouteMatchMetadata']] = None,
                 method_name: Optional[str] = None,
                 prefix: Optional[str] = None,
                 service_name: Optional[str] = None):
        """
        :param Sequence['RouteSpecGrpcRouteMatchMetadataArgs'] metadatas: The data to match from the gRPC request.
        :param str method_name: The method name to match from the request. If you specify a name, you must also specify a `service_name`.
        :param str prefix: The value sent by the client must begin with the specified characters. Must be between 1 and 255 characters in length.
               This parameter must always start with /, which by itself matches all requests to the virtual router service name.
        :param str service_name: The fully qualified domain name for the service to match from the request.
        """
        if metadatas is not None:
            pulumi.set(__self__, "metadatas", metadatas)
        if method_name is not None:
            pulumi.set(__self__, "method_name", method_name)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)
        if service_name is not None:
            pulumi.set(__self__, "service_name", service_name)

    @property
    @pulumi.getter
    def metadatas(self) -> Optional[Sequence['outputs.RouteSpecGrpcRouteMatchMetadata']]:
        """
        The data to match from the gRPC request.
        """
        return pulumi.get(self, "metadatas")

    @property
    @pulumi.getter(name="methodName")
    def method_name(self) -> Optional[str]:
        """
        The method name to match from the request. If you specify a name, you must also specify a `service_name`.
        """
        return pulumi.get(self, "method_name")

    @property
    @pulumi.getter
    def prefix(self) -> Optional[str]:
        """
        The value sent by the client must begin with the specified characters. Must be between 1 and 255 characters in length.
        This parameter must always start with /, which by itself matches all requests to the virtual router service name.
        """
        return pulumi.get(self, "prefix")

    @property
    @pulumi.getter(name="serviceName")
    def service_name(self) -> Optional[str]:
        """
        The fully qualified domain name for the service to match from the request.
        """
        return pulumi.get(self, "service_name")


@pulumi.output_type
class RouteSpecGrpcRouteMatchMetadata(dict):
    def __init__(__self__, *,
                 name: str,
                 invert: Optional[bool] = None,
                 match: Optional['outputs.RouteSpecGrpcRouteMatchMetadataMatch'] = None):
        """
        :param str name: The name of the route. Must be between 1 and 50 characters in length.
        :param bool invert: If `true`, the match is on the opposite of the `match` criteria. Default is `false`.
        :param 'RouteSpecGrpcRouteMatchMetadataMatchArgs' match: The data to match from the request.
        """
        pulumi.set(__self__, "name", name)
        if invert is not None:
            pulumi.set(__self__, "invert", invert)
        if match is not None:
            pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the route. Must be between 1 and 50 characters in length.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def invert(self) -> Optional[bool]:
        """
        If `true`, the match is on the opposite of the `match` criteria. Default is `false`.
        """
        return pulumi.get(self, "invert")

    @property
    @pulumi.getter
    def match(self) -> Optional['outputs.RouteSpecGrpcRouteMatchMetadataMatch']:
        """
        The data to match from the request.
        """
        return pulumi.get(self, "match")


@pulumi.output_type
class RouteSpecGrpcRouteMatchMetadataMatch(dict):
    def __init__(__self__, *,
                 exact: Optional[str] = None,
                 prefix: Optional[str] = None,
                 range: Optional['outputs.RouteSpecGrpcRouteMatchMetadataMatchRange'] = None,
                 regex: Optional[str] = None,
                 suffix: Optional[str] = None):
        """
        :param str exact: The value sent by the client must match the specified value exactly. Must be between 1 and 255 characters in length.
        :param str prefix: The value sent by the client must begin with the specified characters. Must be between 1 and 255 characters in length.
               This parameter must always start with /, which by itself matches all requests to the virtual router service name.
        :param 'RouteSpecGrpcRouteMatchMetadataMatchRangeArgs' range: The object that specifies the range of numbers that the value sent by the client must be included in.
        :param str regex: The value sent by the client must include the specified characters. Must be between 1 and 255 characters in length.
        :param str suffix: The value sent by the client must end with the specified characters. Must be between 1 and 255 characters in length.
        """
        if exact is not None:
            pulumi.set(__self__, "exact", exact)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)
        if range is not None:
            pulumi.set(__self__, "range", range)
        if regex is not None:
            pulumi.set(__self__, "regex", regex)
        if suffix is not None:
            pulumi.set(__self__, "suffix", suffix)

    @property
    @pulumi.getter
    def exact(self) -> Optional[str]:
        """
        The value sent by the client must match the specified value exactly. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "exact")

    @property
    @pulumi.getter
    def prefix(self) -> Optional[str]:
        """
        The value sent by the client must begin with the specified characters. Must be between 1 and 255 characters in length.
        This parameter must always start with /, which by itself matches all requests to the virtual router service name.
        """
        return pulumi.get(self, "prefix")

    @property
    @pulumi.getter
    def range(self) -> Optional['outputs.RouteSpecGrpcRouteMatchMetadataMatchRange']:
        """
        The object that specifies the range of numbers that the value sent by the client must be included in.
        """
        return pulumi.get(self, "range")

    @property
    @pulumi.getter
    def regex(self) -> Optional[str]:
        """
        The value sent by the client must include the specified characters. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "regex")

    @property
    @pulumi.getter
    def suffix(self) -> Optional[str]:
        """
        The value sent by the client must end with the specified characters. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "suffix")


@pulumi.output_type
class RouteSpecGrpcRouteMatchMetadataMatchRange(dict):
    def __init__(__self__, *,
                 end: int,
                 start: int):
        """
        :param int end: The end of the range.
        :param int start: The start of the range.
        """
        pulumi.set(__self__, "end", end)
        pulumi.set(__self__, "start", start)

    @property
    @pulumi.getter
    def end(self) -> int:
        """
        The end of the range.
        """
        return pulumi.get(self, "end")

    @property
    @pulumi.getter
    def start(self) -> int:
        """
        The start of the range.
        """
        return pulumi.get(self, "start")


@pulumi.output_type
class RouteSpecGrpcRouteRetryPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxRetries":
            suggest = "max_retries"
        elif key == "perRetryTimeout":
            suggest = "per_retry_timeout"
        elif key == "grpcRetryEvents":
            suggest = "grpc_retry_events"
        elif key == "httpRetryEvents":
            suggest = "http_retry_events"
        elif key == "tcpRetryEvents":
            suggest = "tcp_retry_events"

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

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

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

    def __init__(__self__, *,
                 max_retries: int,
                 per_retry_timeout: 'outputs.RouteSpecGrpcRouteRetryPolicyPerRetryTimeout',
                 grpc_retry_events: Optional[Sequence[str]] = None,
                 http_retry_events: Optional[Sequence[str]] = None,
                 tcp_retry_events: Optional[Sequence[str]] = None):
        """
        :param int max_retries: The maximum number of retries.
        :param 'RouteSpecGrpcRouteRetryPolicyPerRetryTimeoutArgs' per_retry_timeout: The per-retry timeout.
        :param Sequence[str] grpc_retry_events: List of gRPC retry events.
               Valid values: `cancelled`, `deadline-exceeded`, `internal`, `resource-exhausted`, `unavailable`.
        :param Sequence[str] http_retry_events: List of HTTP retry events.
               Valid values: `client-error` (HTTP status code 409), `gateway-error` (HTTP status codes 502, 503, and 504), `server-error` (HTTP status codes 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, and 511), `stream-error` (retry on refused stream).
               Valid values: `client-error` (HTTP status code 409), `gateway-error` (HTTP status codes 502, 503, and 504), `server-error` (HTTP status codes 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, and 511), `stream-error` (retry on refused stream).
        :param Sequence[str] tcp_retry_events: List of TCP retry events. The only valid value is `connection-error`.
        """
        pulumi.set(__self__, "max_retries", max_retries)
        pulumi.set(__self__, "per_retry_timeout", per_retry_timeout)
        if grpc_retry_events is not None:
            pulumi.set(__self__, "grpc_retry_events", grpc_retry_events)
        if http_retry_events is not None:
            pulumi.set(__self__, "http_retry_events", http_retry_events)
        if tcp_retry_events is not None:
            pulumi.set(__self__, "tcp_retry_events", tcp_retry_events)

    @property
    @pulumi.getter(name="maxRetries")
    def max_retries(self) -> int:
        """
        The maximum number of retries.
        """
        return pulumi.get(self, "max_retries")

    @property
    @pulumi.getter(name="perRetryTimeout")
    def per_retry_timeout(self) -> 'outputs.RouteSpecGrpcRouteRetryPolicyPerRetryTimeout':
        """
        The per-retry timeout.
        """
        return pulumi.get(self, "per_retry_timeout")

    @property
    @pulumi.getter(name="grpcRetryEvents")
    def grpc_retry_events(self) -> Optional[Sequence[str]]:
        """
        List of gRPC retry events.
        Valid values: `cancelled`, `deadline-exceeded`, `internal`, `resource-exhausted`, `unavailable`.
        """
        return pulumi.get(self, "grpc_retry_events")

    @property
    @pulumi.getter(name="httpRetryEvents")
    def http_retry_events(self) -> Optional[Sequence[str]]:
        """
        List of HTTP retry events.
        Valid values: `client-error` (HTTP status code 409), `gateway-error` (HTTP status codes 502, 503, and 504), `server-error` (HTTP status codes 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, and 511), `stream-error` (retry on refused stream).
        Valid values: `client-error` (HTTP status code 409), `gateway-error` (HTTP status codes 502, 503, and 504), `server-error` (HTTP status codes 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, and 511), `stream-error` (retry on refused stream).
        """
        return pulumi.get(self, "http_retry_events")

    @property
    @pulumi.getter(name="tcpRetryEvents")
    def tcp_retry_events(self) -> Optional[Sequence[str]]:
        """
        List of TCP retry events. The only valid value is `connection-error`.
        """
        return pulumi.get(self, "tcp_retry_events")


@pulumi.output_type
class RouteSpecGrpcRouteRetryPolicyPerRetryTimeout(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        """
        :param str unit: Retry unit. Valid values: `ms`, `s`.
        :param int value: Retry value.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        """
        Retry unit. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        Retry value.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class RouteSpecGrpcRouteTimeout(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "perRequest":
            suggest = "per_request"

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

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

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

    def __init__(__self__, *,
                 idle: Optional['outputs.RouteSpecGrpcRouteTimeoutIdle'] = None,
                 per_request: Optional['outputs.RouteSpecGrpcRouteTimeoutPerRequest'] = None):
        """
        :param 'RouteSpecGrpcRouteTimeoutIdleArgs' idle: The idle timeout. An idle timeout bounds the amount of time that a connection may be idle.
        :param 'RouteSpecGrpcRouteTimeoutPerRequestArgs' per_request: The per request timeout.
        """
        if idle is not None:
            pulumi.set(__self__, "idle", idle)
        if per_request is not None:
            pulumi.set(__self__, "per_request", per_request)

    @property
    @pulumi.getter
    def idle(self) -> Optional['outputs.RouteSpecGrpcRouteTimeoutIdle']:
        """
        The idle timeout. An idle timeout bounds the amount of time that a connection may be idle.
        """
        return pulumi.get(self, "idle")

    @property
    @pulumi.getter(name="perRequest")
    def per_request(self) -> Optional['outputs.RouteSpecGrpcRouteTimeoutPerRequest']:
        """
        The per request timeout.
        """
        return pulumi.get(self, "per_request")


@pulumi.output_type
class RouteSpecGrpcRouteTimeoutIdle(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        """
        :param str unit: The unit of time. Valid values: `ms`, `s`.
        :param int value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class RouteSpecGrpcRouteTimeoutPerRequest(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        """
        :param str unit: The unit of time. Valid values: `ms`, `s`.
        :param int value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class RouteSpecHttp2Route(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "retryPolicy":
            suggest = "retry_policy"

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

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

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

    def __init__(__self__, *,
                 action: 'outputs.RouteSpecHttp2RouteAction',
                 match: 'outputs.RouteSpecHttp2RouteMatch',
                 retry_policy: Optional['outputs.RouteSpecHttp2RouteRetryPolicy'] = None,
                 timeout: Optional['outputs.RouteSpecHttp2RouteTimeout'] = None):
        """
        :param 'RouteSpecHttp2RouteActionArgs' action: The action to take if a match is determined.
        :param 'RouteSpecHttp2RouteMatchArgs' match: The criteria for determining an gRPC request match.
        :param 'RouteSpecHttp2RouteRetryPolicyArgs' retry_policy: The retry policy.
        :param 'RouteSpecHttp2RouteTimeoutArgs' timeout: The types of timeouts.
        """
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "match", match)
        if retry_policy is not None:
            pulumi.set(__self__, "retry_policy", retry_policy)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter
    def action(self) -> 'outputs.RouteSpecHttp2RouteAction':
        """
        The action to take if a match is determined.
        """
        return pulumi.get(self, "action")

    @property
    @pulumi.getter
    def match(self) -> 'outputs.RouteSpecHttp2RouteMatch':
        """
        The criteria for determining an gRPC request match.
        """
        return pulumi.get(self, "match")

    @property
    @pulumi.getter(name="retryPolicy")
    def retry_policy(self) -> Optional['outputs.RouteSpecHttp2RouteRetryPolicy']:
        """
        The retry policy.
        """
        return pulumi.get(self, "retry_policy")

    @property
    @pulumi.getter
    def timeout(self) -> Optional['outputs.RouteSpecHttp2RouteTimeout']:
        """
        The types of timeouts.
        """
        return pulumi.get(self, "timeout")


@pulumi.output_type
class RouteSpecHttp2RouteAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "weightedTargets":
            suggest = "weighted_targets"

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

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

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

    def __init__(__self__, *,
                 weighted_targets: Sequence['outputs.RouteSpecHttp2RouteActionWeightedTarget']):
        """
        :param Sequence['RouteSpecHttp2RouteActionWeightedTargetArgs'] weighted_targets: The targets that traffic is routed to when a request matches the route.
               You can specify one or more targets and their relative weights with which to distribute traffic.
        """
        pulumi.set(__self__, "weighted_targets", weighted_targets)

    @property
    @pulumi.getter(name="weightedTargets")
    def weighted_targets(self) -> Sequence['outputs.RouteSpecHttp2RouteActionWeightedTarget']:
        """
        The targets that traffic is routed to when a request matches the route.
        You can specify one or more targets and their relative weights with which to distribute traffic.
        """
        return pulumi.get(self, "weighted_targets")


@pulumi.output_type
class RouteSpecHttp2RouteActionWeightedTarget(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "virtualNode":
            suggest = "virtual_node"

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

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

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

    def __init__(__self__, *,
                 virtual_node: str,
                 weight: int):
        """
        :param str virtual_node: The virtual node to associate with the weighted target. Must be between 1 and 255 characters in length.
        :param int weight: The relative weight of the weighted target. An integer between 0 and 100.
        """
        pulumi.set(__self__, "virtual_node", virtual_node)
        pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter(name="virtualNode")
    def virtual_node(self) -> str:
        """
        The virtual node to associate with the weighted target. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "virtual_node")

    @property
    @pulumi.getter
    def weight(self) -> int:
        """
        The relative weight of the weighted target. An integer between 0 and 100.
        """
        return pulumi.get(self, "weight")


@pulumi.output_type
class RouteSpecHttp2RouteMatch(dict):
    def __init__(__self__, *,
                 prefix: str,
                 headers: Optional[Sequence['outputs.RouteSpecHttp2RouteMatchHeader']] = None,
                 method: Optional[str] = None,
                 scheme: Optional[str] = None):
        """
        :param str prefix: The value sent by the client must begin with the specified characters. Must be between 1 and 255 characters in length.
               This parameter must always start with /, which by itself matches all requests to the virtual router service name.
        :param Sequence['RouteSpecHttp2RouteMatchHeaderArgs'] headers: The client request headers to match on.
        :param str method: The client request header method to match on. Valid values: `GET`, `HEAD`, `POST`, `PUT`, `DELETE`, `CONNECT`, `OPTIONS`, `TRACE`, `PATCH`.
        :param str scheme: The client request header scheme to match on. Valid values: `http`, `https`.
        """
        pulumi.set(__self__, "prefix", prefix)
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if method is not None:
            pulumi.set(__self__, "method", method)
        if scheme is not None:
            pulumi.set(__self__, "scheme", scheme)

    @property
    @pulumi.getter
    def prefix(self) -> str:
        """
        The value sent by the client must begin with the specified characters. Must be between 1 and 255 characters in length.
        This parameter must always start with /, which by itself matches all requests to the virtual router service name.
        """
        return pulumi.get(self, "prefix")

    @property
    @pulumi.getter
    def headers(self) -> Optional[Sequence['outputs.RouteSpecHttp2RouteMatchHeader']]:
        """
        The client request headers to match on.
        """
        return pulumi.get(self, "headers")

    @property
    @pulumi.getter
    def method(self) -> Optional[str]:
        """
        The client request header method to match on. Valid values: `GET`, `HEAD`, `POST`, `PUT`, `DELETE`, `CONNECT`, `OPTIONS`, `TRACE`, `PATCH`.
        """
        return pulumi.get(self, "method")

    @property
    @pulumi.getter
    def scheme(self) -> Optional[str]:
        """
        The client request header scheme to match on. Valid values: `http`, `https`.
        """
        return pulumi.get(self, "scheme")


@pulumi.output_type
class RouteSpecHttp2RouteMatchHeader(dict):
    def __init__(__self__, *,
                 name: str,
                 invert: Optional[bool] = None,
                 match: Optional['outputs.RouteSpecHttp2RouteMatchHeaderMatch'] = None):
        """
        :param str name: A name for the HTTP header in the client request that will be matched on.
        :param bool invert: If `true`, the match is on the opposite of the `match` method and value. Default is `false`.
        :param 'RouteSpecHttp2RouteMatchHeaderMatchArgs' match: The method and value to match the header value sent with a request. Specify one match method.
        """
        pulumi.set(__self__, "name", name)
        if invert is not None:
            pulumi.set(__self__, "invert", invert)
        if match is not None:
            pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        A name for the HTTP header in the client request that will be matched on.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def invert(self) -> Optional[bool]:
        """
        If `true`, the match is on the opposite of the `match` method and value. Default is `false`.
        """
        return pulumi.get(self, "invert")

    @property
    @pulumi.getter
    def match(self) -> Optional['outputs.RouteSpecHttp2RouteMatchHeaderMatch']:
        """
        The method and value to match the header value sent with a request. Specify one match method.
        """
        return pulumi.get(self, "match")


@pulumi.output_type
class RouteSpecHttp2RouteMatchHeaderMatch(dict):
    def __init__(__self__, *,
                 exact: Optional[str] = None,
                 prefix: Optional[str] = None,
                 range: Optional['outputs.RouteSpecHttp2RouteMatchHeaderMatchRange'] = None,
                 regex: Optional[str] = None,
                 suffix: Optional[str] = None):
        """
        :param str exact: The value sent by the client must match the specified value exactly. Must be between 1 and 255 characters in length.
        :param str prefix: The value sent by the client must begin with the specified characters. Must be between 1 and 255 characters in length.
               This parameter must always start with /, which by itself matches all requests to the virtual router service name.
        :param 'RouteSpecHttp2RouteMatchHeaderMatchRangeArgs' range: The object that specifies the range of numbers that the value sent by the client must be included in.
        :param str regex: The value sent by the client must include the specified characters. Must be between 1 and 255 characters in length.
        :param str suffix: The value sent by the client must end with the specified characters. Must be between 1 and 255 characters in length.
        """
        if exact is not None:
            pulumi.set(__self__, "exact", exact)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)
        if range is not None:
            pulumi.set(__self__, "range", range)
        if regex is not None:
            pulumi.set(__self__, "regex", regex)
        if suffix is not None:
            pulumi.set(__self__, "suffix", suffix)

    @property
    @pulumi.getter
    def exact(self) -> Optional[str]:
        """
        The value sent by the client must match the specified value exactly. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "exact")

    @property
    @pulumi.getter
    def prefix(self) -> Optional[str]:
        """
        The value sent by the client must begin with the specified characters. Must be between 1 and 255 characters in length.
        This parameter must always start with /, which by itself matches all requests to the virtual router service name.
        """
        return pulumi.get(self, "prefix")

    @property
    @pulumi.getter
    def range(self) -> Optional['outputs.RouteSpecHttp2RouteMatchHeaderMatchRange']:
        """
        The object that specifies the range of numbers that the value sent by the client must be included in.
        """
        return pulumi.get(self, "range")

    @property
    @pulumi.getter
    def regex(self) -> Optional[str]:
        """
        The value sent by the client must include the specified characters. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "regex")

    @property
    @pulumi.getter
    def suffix(self) -> Optional[str]:
        """
        The value sent by the client must end with the specified characters. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "suffix")


@pulumi.output_type
class RouteSpecHttp2RouteMatchHeaderMatchRange(dict):
    def __init__(__self__, *,
                 end: int,
                 start: int):
        """
        :param int end: The end of the range.
        :param int start: The start of the range.
        """
        pulumi.set(__self__, "end", end)
        pulumi.set(__self__, "start", start)

    @property
    @pulumi.getter
    def end(self) -> int:
        """
        The end of the range.
        """
        return pulumi.get(self, "end")

    @property
    @pulumi.getter
    def start(self) -> int:
        """
        The start of the range.
        """
        return pulumi.get(self, "start")


@pulumi.output_type
class RouteSpecHttp2RouteRetryPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxRetries":
            suggest = "max_retries"
        elif key == "perRetryTimeout":
            suggest = "per_retry_timeout"
        elif key == "httpRetryEvents":
            suggest = "http_retry_events"
        elif key == "tcpRetryEvents":
            suggest = "tcp_retry_events"

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

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

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

    def __init__(__self__, *,
                 max_retries: int,
                 per_retry_timeout: 'outputs.RouteSpecHttp2RouteRetryPolicyPerRetryTimeout',
                 http_retry_events: Optional[Sequence[str]] = None,
                 tcp_retry_events: Optional[Sequence[str]] = None):
        """
        :param int max_retries: The maximum number of retries.
        :param 'RouteSpecHttp2RouteRetryPolicyPerRetryTimeoutArgs' per_retry_timeout: The per-retry timeout.
        :param Sequence[str] http_retry_events: List of HTTP retry events.
               Valid values: `client-error` (HTTP status code 409), `gateway-error` (HTTP status codes 502, 503, and 504), `server-error` (HTTP status codes 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, and 511), `stream-error` (retry on refused stream).
               Valid values: `client-error` (HTTP status code 409), `gateway-error` (HTTP status codes 502, 503, and 504), `server-error` (HTTP status codes 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, and 511), `stream-error` (retry on refused stream).
        :param Sequence[str] tcp_retry_events: List of TCP retry events. The only valid value is `connection-error`.
        """
        pulumi.set(__self__, "max_retries", max_retries)
        pulumi.set(__self__, "per_retry_timeout", per_retry_timeout)
        if http_retry_events is not None:
            pulumi.set(__self__, "http_retry_events", http_retry_events)
        if tcp_retry_events is not None:
            pulumi.set(__self__, "tcp_retry_events", tcp_retry_events)

    @property
    @pulumi.getter(name="maxRetries")
    def max_retries(self) -> int:
        """
        The maximum number of retries.
        """
        return pulumi.get(self, "max_retries")

    @property
    @pulumi.getter(name="perRetryTimeout")
    def per_retry_timeout(self) -> 'outputs.RouteSpecHttp2RouteRetryPolicyPerRetryTimeout':
        """
        The per-retry timeout.
        """
        return pulumi.get(self, "per_retry_timeout")

    @property
    @pulumi.getter(name="httpRetryEvents")
    def http_retry_events(self) -> Optional[Sequence[str]]:
        """
        List of HTTP retry events.
        Valid values: `client-error` (HTTP status code 409), `gateway-error` (HTTP status codes 502, 503, and 504), `server-error` (HTTP status codes 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, and 511), `stream-error` (retry on refused stream).
        Valid values: `client-error` (HTTP status code 409), `gateway-error` (HTTP status codes 502, 503, and 504), `server-error` (HTTP status codes 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, and 511), `stream-error` (retry on refused stream).
        """
        return pulumi.get(self, "http_retry_events")

    @property
    @pulumi.getter(name="tcpRetryEvents")
    def tcp_retry_events(self) -> Optional[Sequence[str]]:
        """
        List of TCP retry events. The only valid value is `connection-error`.
        """
        return pulumi.get(self, "tcp_retry_events")


@pulumi.output_type
class RouteSpecHttp2RouteRetryPolicyPerRetryTimeout(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        """
        :param str unit: Retry unit. Valid values: `ms`, `s`.
        :param int value: Retry value.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        """
        Retry unit. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        Retry value.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class RouteSpecHttp2RouteTimeout(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "perRequest":
            suggest = "per_request"

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

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

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

    def __init__(__self__, *,
                 idle: Optional['outputs.RouteSpecHttp2RouteTimeoutIdle'] = None,
                 per_request: Optional['outputs.RouteSpecHttp2RouteTimeoutPerRequest'] = None):
        """
        :param 'RouteSpecHttp2RouteTimeoutIdleArgs' idle: The idle timeout. An idle timeout bounds the amount of time that a connection may be idle.
        :param 'RouteSpecHttp2RouteTimeoutPerRequestArgs' per_request: The per request timeout.
        """
        if idle is not None:
            pulumi.set(__self__, "idle", idle)
        if per_request is not None:
            pulumi.set(__self__, "per_request", per_request)

    @property
    @pulumi.getter
    def idle(self) -> Optional['outputs.RouteSpecHttp2RouteTimeoutIdle']:
        """
        The idle timeout. An idle timeout bounds the amount of time that a connection may be idle.
        """
        return pulumi.get(self, "idle")

    @property
    @pulumi.getter(name="perRequest")
    def per_request(self) -> Optional['outputs.RouteSpecHttp2RouteTimeoutPerRequest']:
        """
        The per request timeout.
        """
        return pulumi.get(self, "per_request")


@pulumi.output_type
class RouteSpecHttp2RouteTimeoutIdle(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        """
        :param str unit: The unit of time. Valid values: `ms`, `s`.
        :param int value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class RouteSpecHttp2RouteTimeoutPerRequest(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        """
        :param str unit: The unit of time. Valid values: `ms`, `s`.
        :param int value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class RouteSpecHttpRoute(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "retryPolicy":
            suggest = "retry_policy"

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

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

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

    def __init__(__self__, *,
                 action: 'outputs.RouteSpecHttpRouteAction',
                 match: 'outputs.RouteSpecHttpRouteMatch',
                 retry_policy: Optional['outputs.RouteSpecHttpRouteRetryPolicy'] = None,
                 timeout: Optional['outputs.RouteSpecHttpRouteTimeout'] = None):
        """
        :param 'RouteSpecHttpRouteActionArgs' action: The action to take if a match is determined.
        :param 'RouteSpecHttpRouteMatchArgs' match: The criteria for determining an HTTP request match.
        :param 'RouteSpecHttpRouteRetryPolicyArgs' retry_policy: The retry policy.
        :param 'RouteSpecHttpRouteTimeoutArgs' timeout: The types of timeouts.
        """
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "match", match)
        if retry_policy is not None:
            pulumi.set(__self__, "retry_policy", retry_policy)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter
    def action(self) -> 'outputs.RouteSpecHttpRouteAction':
        """
        The action to take if a match is determined.
        """
        return pulumi.get(self, "action")

    @property
    @pulumi.getter
    def match(self) -> 'outputs.RouteSpecHttpRouteMatch':
        """
        The criteria for determining an HTTP request match.
        """
        return pulumi.get(self, "match")

    @property
    @pulumi.getter(name="retryPolicy")
    def retry_policy(self) -> Optional['outputs.RouteSpecHttpRouteRetryPolicy']:
        """
        The retry policy.
        """
        return pulumi.get(self, "retry_policy")

    @property
    @pulumi.getter
    def timeout(self) -> Optional['outputs.RouteSpecHttpRouteTimeout']:
        """
        The types of timeouts.
        """
        return pulumi.get(self, "timeout")


@pulumi.output_type
class RouteSpecHttpRouteAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "weightedTargets":
            suggest = "weighted_targets"

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

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

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

    def __init__(__self__, *,
                 weighted_targets: Sequence['outputs.RouteSpecHttpRouteActionWeightedTarget']):
        """
        :param Sequence['RouteSpecHttpRouteActionWeightedTargetArgs'] weighted_targets: The targets that traffic is routed to when a request matches the route.
               You can specify one or more targets and their relative weights with which to distribute traffic.
        """
        pulumi.set(__self__, "weighted_targets", weighted_targets)

    @property
    @pulumi.getter(name="weightedTargets")
    def weighted_targets(self) -> Sequence['outputs.RouteSpecHttpRouteActionWeightedTarget']:
        """
        The targets that traffic is routed to when a request matches the route.
        You can specify one or more targets and their relative weights with which to distribute traffic.
        """
        return pulumi.get(self, "weighted_targets")


@pulumi.output_type
class RouteSpecHttpRouteActionWeightedTarget(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "virtualNode":
            suggest = "virtual_node"

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

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

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

    def __init__(__self__, *,
                 virtual_node: str,
                 weight: int):
        """
        :param str virtual_node: The virtual node to associate with the weighted target. Must be between 1 and 255 characters in length.
        :param int weight: The relative weight of the weighted target. An integer between 0 and 100.
        """
        pulumi.set(__self__, "virtual_node", virtual_node)
        pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter(name="virtualNode")
    def virtual_node(self) -> str:
        """
        The virtual node to associate with the weighted target. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "virtual_node")

    @property
    @pulumi.getter
    def weight(self) -> int:
        """
        The relative weight of the weighted target. An integer between 0 and 100.
        """
        return pulumi.get(self, "weight")


@pulumi.output_type
class RouteSpecHttpRouteMatch(dict):
    def __init__(__self__, *,
                 prefix: str,
                 headers: Optional[Sequence['outputs.RouteSpecHttpRouteMatchHeader']] = None,
                 method: Optional[str] = None,
                 scheme: Optional[str] = None):
        """
        :param str prefix: The value sent by the client must begin with the specified characters. Must be between 1 and 255 characters in length.
               This parameter must always start with /, which by itself matches all requests to the virtual router service name.
        :param Sequence['RouteSpecHttpRouteMatchHeaderArgs'] headers: The client request headers to match on.
        :param str method: The client request header method to match on. Valid values: `GET`, `HEAD`, `POST`, `PUT`, `DELETE`, `CONNECT`, `OPTIONS`, `TRACE`, `PATCH`.
        :param str scheme: The client request header scheme to match on. Valid values: `http`, `https`.
        """
        pulumi.set(__self__, "prefix", prefix)
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if method is not None:
            pulumi.set(__self__, "method", method)
        if scheme is not None:
            pulumi.set(__self__, "scheme", scheme)

    @property
    @pulumi.getter
    def prefix(self) -> str:
        """
        The value sent by the client must begin with the specified characters. Must be between 1 and 255 characters in length.
        This parameter must always start with /, which by itself matches all requests to the virtual router service name.
        """
        return pulumi.get(self, "prefix")

    @property
    @pulumi.getter
    def headers(self) -> Optional[Sequence['outputs.RouteSpecHttpRouteMatchHeader']]:
        """
        The client request headers to match on.
        """
        return pulumi.get(self, "headers")

    @property
    @pulumi.getter
    def method(self) -> Optional[str]:
        """
        The client request header method to match on. Valid values: `GET`, `HEAD`, `POST`, `PUT`, `DELETE`, `CONNECT`, `OPTIONS`, `TRACE`, `PATCH`.
        """
        return pulumi.get(self, "method")

    @property
    @pulumi.getter
    def scheme(self) -> Optional[str]:
        """
        The client request header scheme to match on. Valid values: `http`, `https`.
        """
        return pulumi.get(self, "scheme")


@pulumi.output_type
class RouteSpecHttpRouteMatchHeader(dict):
    def __init__(__self__, *,
                 name: str,
                 invert: Optional[bool] = None,
                 match: Optional['outputs.RouteSpecHttpRouteMatchHeaderMatch'] = None):
        """
        :param str name: A name for the HTTP header in the client request that will be matched on.
        :param bool invert: If `true`, the match is on the opposite of the `match` method and value. Default is `false`.
        :param 'RouteSpecHttpRouteMatchHeaderMatchArgs' match: The method and value to match the header value sent with a request. Specify one match method.
        """
        pulumi.set(__self__, "name", name)
        if invert is not None:
            pulumi.set(__self__, "invert", invert)
        if match is not None:
            pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        A name for the HTTP header in the client request that will be matched on.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def invert(self) -> Optional[bool]:
        """
        If `true`, the match is on the opposite of the `match` method and value. Default is `false`.
        """
        return pulumi.get(self, "invert")

    @property
    @pulumi.getter
    def match(self) -> Optional['outputs.RouteSpecHttpRouteMatchHeaderMatch']:
        """
        The method and value to match the header value sent with a request. Specify one match method.
        """
        return pulumi.get(self, "match")


@pulumi.output_type
class RouteSpecHttpRouteMatchHeaderMatch(dict):
    def __init__(__self__, *,
                 exact: Optional[str] = None,
                 prefix: Optional[str] = None,
                 range: Optional['outputs.RouteSpecHttpRouteMatchHeaderMatchRange'] = None,
                 regex: Optional[str] = None,
                 suffix: Optional[str] = None):
        """
        :param str exact: The value sent by the client must match the specified value exactly. Must be between 1 and 255 characters in length.
        :param str prefix: The value sent by the client must begin with the specified characters. Must be between 1 and 255 characters in length.
               This parameter must always start with /, which by itself matches all requests to the virtual router service name.
        :param 'RouteSpecHttpRouteMatchHeaderMatchRangeArgs' range: The object that specifies the range of numbers that the value sent by the client must be included in.
        :param str regex: The value sent by the client must include the specified characters. Must be between 1 and 255 characters in length.
        :param str suffix: The value sent by the client must end with the specified characters. Must be between 1 and 255 characters in length.
        """
        if exact is not None:
            pulumi.set(__self__, "exact", exact)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)
        if range is not None:
            pulumi.set(__self__, "range", range)
        if regex is not None:
            pulumi.set(__self__, "regex", regex)
        if suffix is not None:
            pulumi.set(__self__, "suffix", suffix)

    @property
    @pulumi.getter
    def exact(self) -> Optional[str]:
        """
        The value sent by the client must match the specified value exactly. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "exact")

    @property
    @pulumi.getter
    def prefix(self) -> Optional[str]:
        """
        The value sent by the client must begin with the specified characters. Must be between 1 and 255 characters in length.
        This parameter must always start with /, which by itself matches all requests to the virtual router service name.
        """
        return pulumi.get(self, "prefix")

    @property
    @pulumi.getter
    def range(self) -> Optional['outputs.RouteSpecHttpRouteMatchHeaderMatchRange']:
        """
        The object that specifies the range of numbers that the value sent by the client must be included in.
        """
        return pulumi.get(self, "range")

    @property
    @pulumi.getter
    def regex(self) -> Optional[str]:
        """
        The value sent by the client must include the specified characters. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "regex")

    @property
    @pulumi.getter
    def suffix(self) -> Optional[str]:
        """
        The value sent by the client must end with the specified characters. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "suffix")


@pulumi.output_type
class RouteSpecHttpRouteMatchHeaderMatchRange(dict):
    def __init__(__self__, *,
                 end: int,
                 start: int):
        """
        :param int end: The end of the range.
        :param int start: The start of the range.
        """
        pulumi.set(__self__, "end", end)
        pulumi.set(__self__, "start", start)

    @property
    @pulumi.getter
    def end(self) -> int:
        """
        The end of the range.
        """
        return pulumi.get(self, "end")

    @property
    @pulumi.getter
    def start(self) -> int:
        """
        The start of the range.
        """
        return pulumi.get(self, "start")


@pulumi.output_type
class RouteSpecHttpRouteRetryPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxRetries":
            suggest = "max_retries"
        elif key == "perRetryTimeout":
            suggest = "per_retry_timeout"
        elif key == "httpRetryEvents":
            suggest = "http_retry_events"
        elif key == "tcpRetryEvents":
            suggest = "tcp_retry_events"

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

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

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

    def __init__(__self__, *,
                 max_retries: int,
                 per_retry_timeout: 'outputs.RouteSpecHttpRouteRetryPolicyPerRetryTimeout',
                 http_retry_events: Optional[Sequence[str]] = None,
                 tcp_retry_events: Optional[Sequence[str]] = None):
        """
        :param int max_retries: The maximum number of retries.
        :param 'RouteSpecHttpRouteRetryPolicyPerRetryTimeoutArgs' per_retry_timeout: The per-retry timeout.
        :param Sequence[str] http_retry_events: List of HTTP retry events.
               Valid values: `client-error` (HTTP status code 409), `gateway-error` (HTTP status codes 502, 503, and 504), `server-error` (HTTP status codes 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, and 511), `stream-error` (retry on refused stream).
               Valid values: `client-error` (HTTP status code 409), `gateway-error` (HTTP status codes 502, 503, and 504), `server-error` (HTTP status codes 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, and 511), `stream-error` (retry on refused stream).
        :param Sequence[str] tcp_retry_events: List of TCP retry events. The only valid value is `connection-error`.
        """
        pulumi.set(__self__, "max_retries", max_retries)
        pulumi.set(__self__, "per_retry_timeout", per_retry_timeout)
        if http_retry_events is not None:
            pulumi.set(__self__, "http_retry_events", http_retry_events)
        if tcp_retry_events is not None:
            pulumi.set(__self__, "tcp_retry_events", tcp_retry_events)

    @property
    @pulumi.getter(name="maxRetries")
    def max_retries(self) -> int:
        """
        The maximum number of retries.
        """
        return pulumi.get(self, "max_retries")

    @property
    @pulumi.getter(name="perRetryTimeout")
    def per_retry_timeout(self) -> 'outputs.RouteSpecHttpRouteRetryPolicyPerRetryTimeout':
        """
        The per-retry timeout.
        """
        return pulumi.get(self, "per_retry_timeout")

    @property
    @pulumi.getter(name="httpRetryEvents")
    def http_retry_events(self) -> Optional[Sequence[str]]:
        """
        List of HTTP retry events.
        Valid values: `client-error` (HTTP status code 409), `gateway-error` (HTTP status codes 502, 503, and 504), `server-error` (HTTP status codes 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, and 511), `stream-error` (retry on refused stream).
        Valid values: `client-error` (HTTP status code 409), `gateway-error` (HTTP status codes 502, 503, and 504), `server-error` (HTTP status codes 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, and 511), `stream-error` (retry on refused stream).
        """
        return pulumi.get(self, "http_retry_events")

    @property
    @pulumi.getter(name="tcpRetryEvents")
    def tcp_retry_events(self) -> Optional[Sequence[str]]:
        """
        List of TCP retry events. The only valid value is `connection-error`.
        """
        return pulumi.get(self, "tcp_retry_events")


@pulumi.output_type
class RouteSpecHttpRouteRetryPolicyPerRetryTimeout(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        """
        :param str unit: Retry unit. Valid values: `ms`, `s`.
        :param int value: Retry value.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        """
        Retry unit. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        Retry value.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class RouteSpecHttpRouteTimeout(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "perRequest":
            suggest = "per_request"

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

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

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

    def __init__(__self__, *,
                 idle: Optional['outputs.RouteSpecHttpRouteTimeoutIdle'] = None,
                 per_request: Optional['outputs.RouteSpecHttpRouteTimeoutPerRequest'] = None):
        """
        :param 'RouteSpecHttpRouteTimeoutIdleArgs' idle: The idle timeout. An idle timeout bounds the amount of time that a connection may be idle.
        :param 'RouteSpecHttpRouteTimeoutPerRequestArgs' per_request: The per request timeout.
        """
        if idle is not None:
            pulumi.set(__self__, "idle", idle)
        if per_request is not None:
            pulumi.set(__self__, "per_request", per_request)

    @property
    @pulumi.getter
    def idle(self) -> Optional['outputs.RouteSpecHttpRouteTimeoutIdle']:
        """
        The idle timeout. An idle timeout bounds the amount of time that a connection may be idle.
        """
        return pulumi.get(self, "idle")

    @property
    @pulumi.getter(name="perRequest")
    def per_request(self) -> Optional['outputs.RouteSpecHttpRouteTimeoutPerRequest']:
        """
        The per request timeout.
        """
        return pulumi.get(self, "per_request")


@pulumi.output_type
class RouteSpecHttpRouteTimeoutIdle(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        """
        :param str unit: The unit of time. Valid values: `ms`, `s`.
        :param int value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class RouteSpecHttpRouteTimeoutPerRequest(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        """
        :param str unit: The unit of time. Valid values: `ms`, `s`.
        :param int value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class RouteSpecTcpRoute(dict):
    def __init__(__self__, *,
                 action: 'outputs.RouteSpecTcpRouteAction',
                 timeout: Optional['outputs.RouteSpecTcpRouteTimeout'] = None):
        """
        :param 'RouteSpecTcpRouteActionArgs' action: The action to take if a match is determined.
        :param 'RouteSpecTcpRouteTimeoutArgs' timeout: The types of timeouts.
        """
        pulumi.set(__self__, "action", action)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter
    def action(self) -> 'outputs.RouteSpecTcpRouteAction':
        """
        The action to take if a match is determined.
        """
        return pulumi.get(self, "action")

    @property
    @pulumi.getter
    def timeout(self) -> Optional['outputs.RouteSpecTcpRouteTimeout']:
        """
        The types of timeouts.
        """
        return pulumi.get(self, "timeout")


@pulumi.output_type
class RouteSpecTcpRouteAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "weightedTargets":
            suggest = "weighted_targets"

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

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

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

    def __init__(__self__, *,
                 weighted_targets: Sequence['outputs.RouteSpecTcpRouteActionWeightedTarget']):
        """
        :param Sequence['RouteSpecTcpRouteActionWeightedTargetArgs'] weighted_targets: The targets that traffic is routed to when a request matches the route.
               You can specify one or more targets and their relative weights with which to distribute traffic.
        """
        pulumi.set(__self__, "weighted_targets", weighted_targets)

    @property
    @pulumi.getter(name="weightedTargets")
    def weighted_targets(self) -> Sequence['outputs.RouteSpecTcpRouteActionWeightedTarget']:
        """
        The targets that traffic is routed to when a request matches the route.
        You can specify one or more targets and their relative weights with which to distribute traffic.
        """
        return pulumi.get(self, "weighted_targets")


@pulumi.output_type
class RouteSpecTcpRouteActionWeightedTarget(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "virtualNode":
            suggest = "virtual_node"

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

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

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

    def __init__(__self__, *,
                 virtual_node: str,
                 weight: int):
        """
        :param str virtual_node: The virtual node to associate with the weighted target. Must be between 1 and 255 characters in length.
        :param int weight: The relative weight of the weighted target. An integer between 0 and 100.
        """
        pulumi.set(__self__, "virtual_node", virtual_node)
        pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter(name="virtualNode")
    def virtual_node(self) -> str:
        """
        The virtual node to associate with the weighted target. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "virtual_node")

    @property
    @pulumi.getter
    def weight(self) -> int:
        """
        The relative weight of the weighted target. An integer between 0 and 100.
        """
        return pulumi.get(self, "weight")


@pulumi.output_type
class RouteSpecTcpRouteTimeout(dict):
    def __init__(__self__, *,
                 idle: Optional['outputs.RouteSpecTcpRouteTimeoutIdle'] = None):
        """
        :param 'RouteSpecTcpRouteTimeoutIdleArgs' idle: The idle timeout. An idle timeout bounds the amount of time that a connection may be idle.
        """
        if idle is not None:
            pulumi.set(__self__, "idle", idle)

    @property
    @pulumi.getter
    def idle(self) -> Optional['outputs.RouteSpecTcpRouteTimeoutIdle']:
        """
        The idle timeout. An idle timeout bounds the amount of time that a connection may be idle.
        """
        return pulumi.get(self, "idle")


@pulumi.output_type
class RouteSpecTcpRouteTimeoutIdle(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        """
        :param str unit: The unit of time. Valid values: `ms`, `s`.
        :param int value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class VirtualGatewaySpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backendDefaults":
            suggest = "backend_defaults"

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

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

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

    def __init__(__self__, *,
                 listener: 'outputs.VirtualGatewaySpecListener',
                 backend_defaults: Optional['outputs.VirtualGatewaySpecBackendDefaults'] = None,
                 logging: Optional['outputs.VirtualGatewaySpecLogging'] = None):
        """
        :param 'VirtualGatewaySpecListenerArgs' listener: The listeners that the mesh endpoint is expected to receive inbound traffic from. You can specify one listener.
        :param 'VirtualGatewaySpecBackendDefaultsArgs' backend_defaults: The defaults for backends.
        :param 'VirtualGatewaySpecLoggingArgs' logging: The inbound and outbound access logging information for the virtual gateway.
        """
        pulumi.set(__self__, "listener", listener)
        if backend_defaults is not None:
            pulumi.set(__self__, "backend_defaults", backend_defaults)
        if logging is not None:
            pulumi.set(__self__, "logging", logging)

    @property
    @pulumi.getter
    def listener(self) -> 'outputs.VirtualGatewaySpecListener':
        """
        The listeners that the mesh endpoint is expected to receive inbound traffic from. You can specify one listener.
        """
        return pulumi.get(self, "listener")

    @property
    @pulumi.getter(name="backendDefaults")
    def backend_defaults(self) -> Optional['outputs.VirtualGatewaySpecBackendDefaults']:
        """
        The defaults for backends.
        """
        return pulumi.get(self, "backend_defaults")

    @property
    @pulumi.getter
    def logging(self) -> Optional['outputs.VirtualGatewaySpecLogging']:
        """
        The inbound and outbound access logging information for the virtual gateway.
        """
        return pulumi.get(self, "logging")


@pulumi.output_type
class VirtualGatewaySpecBackendDefaults(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientPolicy":
            suggest = "client_policy"

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

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

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

    def __init__(__self__, *,
                 client_policy: Optional['outputs.VirtualGatewaySpecBackendDefaultsClientPolicy'] = None):
        """
        :param 'VirtualGatewaySpecBackendDefaultsClientPolicyArgs' client_policy: The default client policy for virtual gateway backends.
        """
        if client_policy is not None:
            pulumi.set(__self__, "client_policy", client_policy)

    @property
    @pulumi.getter(name="clientPolicy")
    def client_policy(self) -> Optional['outputs.VirtualGatewaySpecBackendDefaultsClientPolicy']:
        """
        The default client policy for virtual gateway backends.
        """
        return pulumi.get(self, "client_policy")


@pulumi.output_type
class VirtualGatewaySpecBackendDefaultsClientPolicy(dict):
    def __init__(__self__, *,
                 tls: Optional['outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTls'] = None):
        """
        :param 'VirtualGatewaySpecBackendDefaultsClientPolicyTlsArgs' tls: The Transport Layer Security (TLS) client policy.
        """
        if tls is not None:
            pulumi.set(__self__, "tls", tls)

    @property
    @pulumi.getter
    def tls(self) -> Optional['outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTls']:
        """
        The Transport Layer Security (TLS) client policy.
        """
        return pulumi.get(self, "tls")


@pulumi.output_type
class VirtualGatewaySpecBackendDefaultsClientPolicyTls(dict):
    def __init__(__self__, *,
                 validation: 'outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidation',
                 certificate: Optional['outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsCertificate'] = None,
                 enforce: Optional[bool] = None,
                 ports: Optional[Sequence[int]] = None):
        """
        :param 'VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationArgs' validation: The listener's Transport Layer Security (TLS) validation context.
        :param 'VirtualGatewaySpecBackendDefaultsClientPolicyTlsCertificateArgs' certificate: The listener's TLS certificate.
        :param bool enforce: Whether the policy is enforced. Default is `true`.
        :param Sequence[int] ports: One or more ports that the policy is enforced for.
        """
        pulumi.set(__self__, "validation", validation)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if enforce is not None:
            pulumi.set(__self__, "enforce", enforce)
        if ports is not None:
            pulumi.set(__self__, "ports", ports)

    @property
    @pulumi.getter
    def validation(self) -> 'outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidation':
        """
        The listener's Transport Layer Security (TLS) validation context.
        """
        return pulumi.get(self, "validation")

    @property
    @pulumi.getter
    def certificate(self) -> Optional['outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsCertificate']:
        """
        The listener's TLS certificate.
        """
        return pulumi.get(self, "certificate")

    @property
    @pulumi.getter
    def enforce(self) -> Optional[bool]:
        """
        Whether the policy is enforced. Default is `true`.
        """
        return pulumi.get(self, "enforce")

    @property
    @pulumi.getter
    def ports(self) -> Optional[Sequence[int]]:
        """
        One or more ports that the policy is enforced for.
        """
        return pulumi.get(self, "ports")


@pulumi.output_type
class VirtualGatewaySpecBackendDefaultsClientPolicyTlsCertificate(dict):
    def __init__(__self__, *,
                 file: Optional['outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsCertificateFile'] = None,
                 sds: Optional['outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsCertificateSds'] = None):
        """
        :param 'VirtualGatewaySpecBackendDefaultsClientPolicyTlsCertificateFileArgs' file: A local file certificate.
        :param 'VirtualGatewaySpecBackendDefaultsClientPolicyTlsCertificateSdsArgs' sds: A [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        if file is not None:
            pulumi.set(__self__, "file", file)
        if sds is not None:
            pulumi.set(__self__, "sds", sds)

    @property
    @pulumi.getter
    def file(self) -> Optional['outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsCertificateFile']:
        """
        A local file certificate.
        """
        return pulumi.get(self, "file")

    @property
    @pulumi.getter
    def sds(self) -> Optional['outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsCertificateSds']:
        """
        A [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        return pulumi.get(self, "sds")


@pulumi.output_type
class VirtualGatewaySpecBackendDefaultsClientPolicyTlsCertificateFile(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certificateChain":
            suggest = "certificate_chain"
        elif key == "privateKey":
            suggest = "private_key"

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

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

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

    def __init__(__self__, *,
                 certificate_chain: str,
                 private_key: str):
        """
        :param str certificate_chain: The certificate trust chain for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        :param str private_key: The private key for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "certificate_chain", certificate_chain)
        pulumi.set(__self__, "private_key", private_key)

    @property
    @pulumi.getter(name="certificateChain")
    def certificate_chain(self) -> str:
        """
        The certificate trust chain for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "certificate_chain")

    @property
    @pulumi.getter(name="privateKey")
    def private_key(self) -> str:
        """
        The private key for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "private_key")


@pulumi.output_type
class VirtualGatewaySpecBackendDefaultsClientPolicyTlsCertificateSds(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secretName":
            suggest = "secret_name"

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

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

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

    def __init__(__self__, *,
                 secret_name: str):
        """
        :param str secret_name: The name of the secret for a virtual gateway's Transport Layer Security (TLS) Secret Discovery Service validation context trust.
        """
        pulumi.set(__self__, "secret_name", secret_name)

    @property
    @pulumi.getter(name="secretName")
    def secret_name(self) -> str:
        """
        The name of the secret for a virtual gateway's Transport Layer Security (TLS) Secret Discovery Service validation context trust.
        """
        return pulumi.get(self, "secret_name")


@pulumi.output_type
class VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidation(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "subjectAlternativeNames":
            suggest = "subject_alternative_names"

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

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

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

    def __init__(__self__, *,
                 trust: 'outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrust',
                 subject_alternative_names: Optional['outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNames'] = None):
        """
        :param 'VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustArgs' trust: The TLS validation context trust.
        :param 'VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesArgs' subject_alternative_names: The SANs for a virtual gateway's listener's Transport Layer Security (TLS) validation context.
        """
        pulumi.set(__self__, "trust", trust)
        if subject_alternative_names is not None:
            pulumi.set(__self__, "subject_alternative_names", subject_alternative_names)

    @property
    @pulumi.getter
    def trust(self) -> 'outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrust':
        """
        The TLS validation context trust.
        """
        return pulumi.get(self, "trust")

    @property
    @pulumi.getter(name="subjectAlternativeNames")
    def subject_alternative_names(self) -> Optional['outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNames']:
        """
        The SANs for a virtual gateway's listener's Transport Layer Security (TLS) validation context.
        """
        return pulumi.get(self, "subject_alternative_names")


@pulumi.output_type
class VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNames(dict):
    def __init__(__self__, *,
                 match: 'outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatch'):
        """
        :param 'VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatchArgs' match: The criteria for determining a SAN's match.
        """
        pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def match(self) -> 'outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatch':
        """
        The criteria for determining a SAN's match.
        """
        return pulumi.get(self, "match")


@pulumi.output_type
class VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatch(dict):
    def __init__(__self__, *,
                 exacts: Sequence[str]):
        """
        :param Sequence[str] exacts: The values sent must match the specified values exactly.
        """
        pulumi.set(__self__, "exacts", exacts)

    @property
    @pulumi.getter
    def exacts(self) -> Sequence[str]:
        """
        The values sent must match the specified values exactly.
        """
        return pulumi.get(self, "exacts")


@pulumi.output_type
class VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrust(dict):
    def __init__(__self__, *,
                 acm: Optional['outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustAcm'] = None,
                 file: Optional['outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustFile'] = None,
                 sds: Optional['outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustSds'] = None):
        """
        :param 'VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustAcmArgs' acm: The TLS validation context trust for an AWS Certificate Manager (ACM) certificate.
        :param 'VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustFileArgs' file: The TLS validation context trust for a local file certificate.
        :param 'VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustSdsArgs' sds: The TLS validation context trust for a [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        if acm is not None:
            pulumi.set(__self__, "acm", acm)
        if file is not None:
            pulumi.set(__self__, "file", file)
        if sds is not None:
            pulumi.set(__self__, "sds", sds)

    @property
    @pulumi.getter
    def acm(self) -> Optional['outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustAcm']:
        """
        The TLS validation context trust for an AWS Certificate Manager (ACM) certificate.
        """
        return pulumi.get(self, "acm")

    @property
    @pulumi.getter
    def file(self) -> Optional['outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustFile']:
        """
        The TLS validation context trust for a local file certificate.
        """
        return pulumi.get(self, "file")

    @property
    @pulumi.getter
    def sds(self) -> Optional['outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustSds']:
        """
        The TLS validation context trust for a [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        return pulumi.get(self, "sds")


@pulumi.output_type
class VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustAcm(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certificateAuthorityArns":
            suggest = "certificate_authority_arns"

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

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

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

    def __init__(__self__, *,
                 certificate_authority_arns: Sequence[str]):
        """
        :param Sequence[str] certificate_authority_arns: One or more ACM Amazon Resource Name (ARN)s.
        """
        pulumi.set(__self__, "certificate_authority_arns", certificate_authority_arns)

    @property
    @pulumi.getter(name="certificateAuthorityArns")
    def certificate_authority_arns(self) -> Sequence[str]:
        """
        One or more ACM Amazon Resource Name (ARN)s.
        """
        return pulumi.get(self, "certificate_authority_arns")


@pulumi.output_type
class VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustFile(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certificateChain":
            suggest = "certificate_chain"

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

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

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

    def __init__(__self__, *,
                 certificate_chain: str):
        """
        :param str certificate_chain: The certificate trust chain for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "certificate_chain", certificate_chain)

    @property
    @pulumi.getter(name="certificateChain")
    def certificate_chain(self) -> str:
        """
        The certificate trust chain for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "certificate_chain")


@pulumi.output_type
class VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustSds(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secretName":
            suggest = "secret_name"

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

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

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

    def __init__(__self__, *,
                 secret_name: str):
        """
        :param str secret_name: The name of the secret for a virtual gateway's Transport Layer Security (TLS) Secret Discovery Service validation context trust.
        """
        pulumi.set(__self__, "secret_name", secret_name)

    @property
    @pulumi.getter(name="secretName")
    def secret_name(self) -> str:
        """
        The name of the secret for a virtual gateway's Transport Layer Security (TLS) Secret Discovery Service validation context trust.
        """
        return pulumi.get(self, "secret_name")


@pulumi.output_type
class VirtualGatewaySpecListener(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "portMapping":
            suggest = "port_mapping"
        elif key == "connectionPool":
            suggest = "connection_pool"
        elif key == "healthCheck":
            suggest = "health_check"

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

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

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

    def __init__(__self__, *,
                 port_mapping: 'outputs.VirtualGatewaySpecListenerPortMapping',
                 connection_pool: Optional['outputs.VirtualGatewaySpecListenerConnectionPool'] = None,
                 health_check: Optional['outputs.VirtualGatewaySpecListenerHealthCheck'] = None,
                 tls: Optional['outputs.VirtualGatewaySpecListenerTls'] = None):
        """
        :param 'VirtualGatewaySpecListenerPortMappingArgs' port_mapping: The port mapping information for the listener.
        :param 'VirtualGatewaySpecListenerConnectionPoolArgs' connection_pool: The connection pool information for the listener.
        :param 'VirtualGatewaySpecListenerHealthCheckArgs' health_check: The health check information for the listener.
        :param 'VirtualGatewaySpecListenerTlsArgs' tls: The Transport Layer Security (TLS) properties for the listener
        """
        pulumi.set(__self__, "port_mapping", port_mapping)
        if connection_pool is not None:
            pulumi.set(__self__, "connection_pool", connection_pool)
        if health_check is not None:
            pulumi.set(__self__, "health_check", health_check)
        if tls is not None:
            pulumi.set(__self__, "tls", tls)

    @property
    @pulumi.getter(name="portMapping")
    def port_mapping(self) -> 'outputs.VirtualGatewaySpecListenerPortMapping':
        """
        The port mapping information for the listener.
        """
        return pulumi.get(self, "port_mapping")

    @property
    @pulumi.getter(name="connectionPool")
    def connection_pool(self) -> Optional['outputs.VirtualGatewaySpecListenerConnectionPool']:
        """
        The connection pool information for the listener.
        """
        return pulumi.get(self, "connection_pool")

    @property
    @pulumi.getter(name="healthCheck")
    def health_check(self) -> Optional['outputs.VirtualGatewaySpecListenerHealthCheck']:
        """
        The health check information for the listener.
        """
        return pulumi.get(self, "health_check")

    @property
    @pulumi.getter
    def tls(self) -> Optional['outputs.VirtualGatewaySpecListenerTls']:
        """
        The Transport Layer Security (TLS) properties for the listener
        """
        return pulumi.get(self, "tls")


@pulumi.output_type
class VirtualGatewaySpecListenerConnectionPool(dict):
    def __init__(__self__, *,
                 grpc: Optional['outputs.VirtualGatewaySpecListenerConnectionPoolGrpc'] = None,
                 http: Optional['outputs.VirtualGatewaySpecListenerConnectionPoolHttp'] = None,
                 http2: Optional['outputs.VirtualGatewaySpecListenerConnectionPoolHttp2'] = None):
        """
        :param 'VirtualGatewaySpecListenerConnectionPoolGrpcArgs' grpc: Connection pool information for gRPC listeners.
        :param 'VirtualGatewaySpecListenerConnectionPoolHttpArgs' http: Connection pool information for HTTP listeners.
        :param 'VirtualGatewaySpecListenerConnectionPoolHttp2Args' http2: Connection pool information for HTTP2 listeners.
        """
        if grpc is not None:
            pulumi.set(__self__, "grpc", grpc)
        if http is not None:
            pulumi.set(__self__, "http", http)
        if http2 is not None:
            pulumi.set(__self__, "http2", http2)

    @property
    @pulumi.getter
    def grpc(self) -> Optional['outputs.VirtualGatewaySpecListenerConnectionPoolGrpc']:
        """
        Connection pool information for gRPC listeners.
        """
        return pulumi.get(self, "grpc")

    @property
    @pulumi.getter
    def http(self) -> Optional['outputs.VirtualGatewaySpecListenerConnectionPoolHttp']:
        """
        Connection pool information for HTTP listeners.
        """
        return pulumi.get(self, "http")

    @property
    @pulumi.getter
    def http2(self) -> Optional['outputs.VirtualGatewaySpecListenerConnectionPoolHttp2']:
        """
        Connection pool information for HTTP2 listeners.
        """
        return pulumi.get(self, "http2")


@pulumi.output_type
class VirtualGatewaySpecListenerConnectionPoolGrpc(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxRequests":
            suggest = "max_requests"

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

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

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

    def __init__(__self__, *,
                 max_requests: int):
        """
        :param int max_requests: Maximum number of inflight requests Envoy can concurrently support across hosts in upstream cluster. Minimum value of `1`.
        """
        pulumi.set(__self__, "max_requests", max_requests)

    @property
    @pulumi.getter(name="maxRequests")
    def max_requests(self) -> int:
        """
        Maximum number of inflight requests Envoy can concurrently support across hosts in upstream cluster. Minimum value of `1`.
        """
        return pulumi.get(self, "max_requests")


@pulumi.output_type
class VirtualGatewaySpecListenerConnectionPoolHttp2(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxRequests":
            suggest = "max_requests"

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

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

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

    def __init__(__self__, *,
                 max_requests: int):
        """
        :param int max_requests: Maximum number of inflight requests Envoy can concurrently support across hosts in upstream cluster. Minimum value of `1`.
        """
        pulumi.set(__self__, "max_requests", max_requests)

    @property
    @pulumi.getter(name="maxRequests")
    def max_requests(self) -> int:
        """
        Maximum number of inflight requests Envoy can concurrently support across hosts in upstream cluster. Minimum value of `1`.
        """
        return pulumi.get(self, "max_requests")


@pulumi.output_type
class VirtualGatewaySpecListenerConnectionPoolHttp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxConnections":
            suggest = "max_connections"
        elif key == "maxPendingRequests":
            suggest = "max_pending_requests"

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

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

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

    def __init__(__self__, *,
                 max_connections: int,
                 max_pending_requests: Optional[int] = None):
        """
        :param int max_connections: Maximum number of outbound TCP connections Envoy can establish concurrently with all hosts in upstream cluster. Minimum value of `1`.
        :param int max_pending_requests: Number of overflowing requests after `max_connections` Envoy will queue to upstream cluster. Minimum value of `1`.
        """
        pulumi.set(__self__, "max_connections", max_connections)
        if max_pending_requests is not None:
            pulumi.set(__self__, "max_pending_requests", max_pending_requests)

    @property
    @pulumi.getter(name="maxConnections")
    def max_connections(self) -> int:
        """
        Maximum number of outbound TCP connections Envoy can establish concurrently with all hosts in upstream cluster. Minimum value of `1`.
        """
        return pulumi.get(self, "max_connections")

    @property
    @pulumi.getter(name="maxPendingRequests")
    def max_pending_requests(self) -> Optional[int]:
        """
        Number of overflowing requests after `max_connections` Envoy will queue to upstream cluster. Minimum value of `1`.
        """
        return pulumi.get(self, "max_pending_requests")


@pulumi.output_type
class VirtualGatewaySpecListenerHealthCheck(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "healthyThreshold":
            suggest = "healthy_threshold"
        elif key == "intervalMillis":
            suggest = "interval_millis"
        elif key == "timeoutMillis":
            suggest = "timeout_millis"
        elif key == "unhealthyThreshold":
            suggest = "unhealthy_threshold"

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

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

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

    def __init__(__self__, *,
                 healthy_threshold: int,
                 interval_millis: int,
                 protocol: str,
                 timeout_millis: int,
                 unhealthy_threshold: int,
                 path: Optional[str] = None,
                 port: Optional[int] = None):
        """
        :param int healthy_threshold: The number of consecutive successful health checks that must occur before declaring listener healthy.
        :param int interval_millis: The time period in milliseconds between each health check execution.
        :param str protocol: The protocol for the health check request. Valid values are `http`, `http2`, and `grpc`.
        :param int timeout_millis: The amount of time to wait when receiving a response from the health check, in milliseconds.
        :param int unhealthy_threshold: The number of consecutive failed health checks that must occur before declaring a virtual gateway unhealthy.
        :param str path: The destination path for the health check request. This is only required if the specified protocol is `http` or `http2`.
        :param int port: The destination port for the health check request. This port must match the port defined in the `port_mapping` for the listener.
        """
        pulumi.set(__self__, "healthy_threshold", healthy_threshold)
        pulumi.set(__self__, "interval_millis", interval_millis)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "timeout_millis", timeout_millis)
        pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if port is not None:
            pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter(name="healthyThreshold")
    def healthy_threshold(self) -> int:
        """
        The number of consecutive successful health checks that must occur before declaring listener healthy.
        """
        return pulumi.get(self, "healthy_threshold")

    @property
    @pulumi.getter(name="intervalMillis")
    def interval_millis(self) -> int:
        """
        The time period in milliseconds between each health check execution.
        """
        return pulumi.get(self, "interval_millis")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        The protocol for the health check request. Valid values are `http`, `http2`, and `grpc`.
        """
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter(name="timeoutMillis")
    def timeout_millis(self) -> int:
        """
        The amount of time to wait when receiving a response from the health check, in milliseconds.
        """
        return pulumi.get(self, "timeout_millis")

    @property
    @pulumi.getter(name="unhealthyThreshold")
    def unhealthy_threshold(self) -> int:
        """
        The number of consecutive failed health checks that must occur before declaring a virtual gateway unhealthy.
        """
        return pulumi.get(self, "unhealthy_threshold")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        The destination path for the health check request. This is only required if the specified protocol is `http` or `http2`.
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        The destination port for the health check request. This port must match the port defined in the `port_mapping` for the listener.
        """
        return pulumi.get(self, "port")


@pulumi.output_type
class VirtualGatewaySpecListenerPortMapping(dict):
    def __init__(__self__, *,
                 port: int,
                 protocol: str):
        """
        :param int port: The port used for the port mapping.
        :param str protocol: The protocol used for the port mapping. Valid values are `http`, `http2`, `tcp` and `grpc`.
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "protocol", protocol)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port used for the port mapping.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        The protocol used for the port mapping. Valid values are `http`, `http2`, `tcp` and `grpc`.
        """
        return pulumi.get(self, "protocol")


@pulumi.output_type
class VirtualGatewaySpecListenerTls(dict):
    def __init__(__self__, *,
                 certificate: 'outputs.VirtualGatewaySpecListenerTlsCertificate',
                 mode: str,
                 validation: Optional['outputs.VirtualGatewaySpecListenerTlsValidation'] = None):
        """
        :param 'VirtualGatewaySpecListenerTlsCertificateArgs' certificate: The listener's TLS certificate.
        :param str mode: The listener's TLS mode. Valid values: `DISABLED`, `PERMISSIVE`, `STRICT`.
        :param 'VirtualGatewaySpecListenerTlsValidationArgs' validation: The listener's Transport Layer Security (TLS) validation context.
        """
        pulumi.set(__self__, "certificate", certificate)
        pulumi.set(__self__, "mode", mode)
        if validation is not None:
            pulumi.set(__self__, "validation", validation)

    @property
    @pulumi.getter
    def certificate(self) -> 'outputs.VirtualGatewaySpecListenerTlsCertificate':
        """
        The listener's TLS certificate.
        """
        return pulumi.get(self, "certificate")

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        The listener's TLS mode. Valid values: `DISABLED`, `PERMISSIVE`, `STRICT`.
        """
        return pulumi.get(self, "mode")

    @property
    @pulumi.getter
    def validation(self) -> Optional['outputs.VirtualGatewaySpecListenerTlsValidation']:
        """
        The listener's Transport Layer Security (TLS) validation context.
        """
        return pulumi.get(self, "validation")


@pulumi.output_type
class VirtualGatewaySpecListenerTlsCertificate(dict):
    def __init__(__self__, *,
                 acm: Optional['outputs.VirtualGatewaySpecListenerTlsCertificateAcm'] = None,
                 file: Optional['outputs.VirtualGatewaySpecListenerTlsCertificateFile'] = None,
                 sds: Optional['outputs.VirtualGatewaySpecListenerTlsCertificateSds'] = None):
        """
        :param 'VirtualGatewaySpecListenerTlsCertificateAcmArgs' acm: An AWS Certificate Manager (ACM) certificate.
        :param 'VirtualGatewaySpecListenerTlsCertificateFileArgs' file: A local file certificate.
        :param 'VirtualGatewaySpecListenerTlsCertificateSdsArgs' sds: A [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        if acm is not None:
            pulumi.set(__self__, "acm", acm)
        if file is not None:
            pulumi.set(__self__, "file", file)
        if sds is not None:
            pulumi.set(__self__, "sds", sds)

    @property
    @pulumi.getter
    def acm(self) -> Optional['outputs.VirtualGatewaySpecListenerTlsCertificateAcm']:
        """
        An AWS Certificate Manager (ACM) certificate.
        """
        return pulumi.get(self, "acm")

    @property
    @pulumi.getter
    def file(self) -> Optional['outputs.VirtualGatewaySpecListenerTlsCertificateFile']:
        """
        A local file certificate.
        """
        return pulumi.get(self, "file")

    @property
    @pulumi.getter
    def sds(self) -> Optional['outputs.VirtualGatewaySpecListenerTlsCertificateSds']:
        """
        A [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        return pulumi.get(self, "sds")


@pulumi.output_type
class VirtualGatewaySpecListenerTlsCertificateAcm(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certificateArn":
            suggest = "certificate_arn"

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

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

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

    def __init__(__self__, *,
                 certificate_arn: str):
        """
        :param str certificate_arn: The Amazon Resource Name (ARN) for the certificate.
        """
        pulumi.set(__self__, "certificate_arn", certificate_arn)

    @property
    @pulumi.getter(name="certificateArn")
    def certificate_arn(self) -> str:
        """
        The Amazon Resource Name (ARN) for the certificate.
        """
        return pulumi.get(self, "certificate_arn")


@pulumi.output_type
class VirtualGatewaySpecListenerTlsCertificateFile(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certificateChain":
            suggest = "certificate_chain"
        elif key == "privateKey":
            suggest = "private_key"

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

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

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

    def __init__(__self__, *,
                 certificate_chain: str,
                 private_key: str):
        """
        :param str certificate_chain: The certificate trust chain for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        :param str private_key: The private key for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "certificate_chain", certificate_chain)
        pulumi.set(__self__, "private_key", private_key)

    @property
    @pulumi.getter(name="certificateChain")
    def certificate_chain(self) -> str:
        """
        The certificate trust chain for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "certificate_chain")

    @property
    @pulumi.getter(name="privateKey")
    def private_key(self) -> str:
        """
        The private key for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "private_key")


@pulumi.output_type
class VirtualGatewaySpecListenerTlsCertificateSds(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secretName":
            suggest = "secret_name"

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

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

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

    def __init__(__self__, *,
                 secret_name: str):
        """
        :param str secret_name: The name of the secret for a virtual gateway's Transport Layer Security (TLS) Secret Discovery Service validation context trust.
        """
        pulumi.set(__self__, "secret_name", secret_name)

    @property
    @pulumi.getter(name="secretName")
    def secret_name(self) -> str:
        """
        The name of the secret for a virtual gateway's Transport Layer Security (TLS) Secret Discovery Service validation context trust.
        """
        return pulumi.get(self, "secret_name")


@pulumi.output_type
class VirtualGatewaySpecListenerTlsValidation(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "subjectAlternativeNames":
            suggest = "subject_alternative_names"

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

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

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

    def __init__(__self__, *,
                 trust: 'outputs.VirtualGatewaySpecListenerTlsValidationTrust',
                 subject_alternative_names: Optional['outputs.VirtualGatewaySpecListenerTlsValidationSubjectAlternativeNames'] = None):
        """
        :param 'VirtualGatewaySpecListenerTlsValidationTrustArgs' trust: The TLS validation context trust.
        :param 'VirtualGatewaySpecListenerTlsValidationSubjectAlternativeNamesArgs' subject_alternative_names: The SANs for a virtual gateway's listener's Transport Layer Security (TLS) validation context.
        """
        pulumi.set(__self__, "trust", trust)
        if subject_alternative_names is not None:
            pulumi.set(__self__, "subject_alternative_names", subject_alternative_names)

    @property
    @pulumi.getter
    def trust(self) -> 'outputs.VirtualGatewaySpecListenerTlsValidationTrust':
        """
        The TLS validation context trust.
        """
        return pulumi.get(self, "trust")

    @property
    @pulumi.getter(name="subjectAlternativeNames")
    def subject_alternative_names(self) -> Optional['outputs.VirtualGatewaySpecListenerTlsValidationSubjectAlternativeNames']:
        """
        The SANs for a virtual gateway's listener's Transport Layer Security (TLS) validation context.
        """
        return pulumi.get(self, "subject_alternative_names")


@pulumi.output_type
class VirtualGatewaySpecListenerTlsValidationSubjectAlternativeNames(dict):
    def __init__(__self__, *,
                 match: 'outputs.VirtualGatewaySpecListenerTlsValidationSubjectAlternativeNamesMatch'):
        """
        :param 'VirtualGatewaySpecListenerTlsValidationSubjectAlternativeNamesMatchArgs' match: The criteria for determining a SAN's match.
        """
        pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def match(self) -> 'outputs.VirtualGatewaySpecListenerTlsValidationSubjectAlternativeNamesMatch':
        """
        The criteria for determining a SAN's match.
        """
        return pulumi.get(self, "match")


@pulumi.output_type
class VirtualGatewaySpecListenerTlsValidationSubjectAlternativeNamesMatch(dict):
    def __init__(__self__, *,
                 exacts: Sequence[str]):
        """
        :param Sequence[str] exacts: The values sent must match the specified values exactly.
        """
        pulumi.set(__self__, "exacts", exacts)

    @property
    @pulumi.getter
    def exacts(self) -> Sequence[str]:
        """
        The values sent must match the specified values exactly.
        """
        return pulumi.get(self, "exacts")


@pulumi.output_type
class VirtualGatewaySpecListenerTlsValidationTrust(dict):
    def __init__(__self__, *,
                 file: Optional['outputs.VirtualGatewaySpecListenerTlsValidationTrustFile'] = None,
                 sds: Optional['outputs.VirtualGatewaySpecListenerTlsValidationTrustSds'] = None):
        """
        :param 'VirtualGatewaySpecListenerTlsValidationTrustFileArgs' file: The TLS validation context trust for a local file certificate.
        :param 'VirtualGatewaySpecListenerTlsValidationTrustSdsArgs' sds: The TLS validation context trust for a [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        if file is not None:
            pulumi.set(__self__, "file", file)
        if sds is not None:
            pulumi.set(__self__, "sds", sds)

    @property
    @pulumi.getter
    def file(self) -> Optional['outputs.VirtualGatewaySpecListenerTlsValidationTrustFile']:
        """
        The TLS validation context trust for a local file certificate.
        """
        return pulumi.get(self, "file")

    @property
    @pulumi.getter
    def sds(self) -> Optional['outputs.VirtualGatewaySpecListenerTlsValidationTrustSds']:
        """
        The TLS validation context trust for a [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        return pulumi.get(self, "sds")


@pulumi.output_type
class VirtualGatewaySpecListenerTlsValidationTrustFile(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certificateChain":
            suggest = "certificate_chain"

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

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

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

    def __init__(__self__, *,
                 certificate_chain: str):
        """
        :param str certificate_chain: The certificate trust chain for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "certificate_chain", certificate_chain)

    @property
    @pulumi.getter(name="certificateChain")
    def certificate_chain(self) -> str:
        """
        The certificate trust chain for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "certificate_chain")


@pulumi.output_type
class VirtualGatewaySpecListenerTlsValidationTrustSds(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secretName":
            suggest = "secret_name"

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

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

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

    def __init__(__self__, *,
                 secret_name: str):
        """
        :param str secret_name: The name of the secret for a virtual gateway's Transport Layer Security (TLS) Secret Discovery Service validation context trust.
        """
        pulumi.set(__self__, "secret_name", secret_name)

    @property
    @pulumi.getter(name="secretName")
    def secret_name(self) -> str:
        """
        The name of the secret for a virtual gateway's Transport Layer Security (TLS) Secret Discovery Service validation context trust.
        """
        return pulumi.get(self, "secret_name")


@pulumi.output_type
class VirtualGatewaySpecLogging(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessLog":
            suggest = "access_log"

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

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

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

    def __init__(__self__, *,
                 access_log: Optional['outputs.VirtualGatewaySpecLoggingAccessLog'] = None):
        """
        :param 'VirtualGatewaySpecLoggingAccessLogArgs' access_log: The access log configuration for a virtual gateway.
        """
        if access_log is not None:
            pulumi.set(__self__, "access_log", access_log)

    @property
    @pulumi.getter(name="accessLog")
    def access_log(self) -> Optional['outputs.VirtualGatewaySpecLoggingAccessLog']:
        """
        The access log configuration for a virtual gateway.
        """
        return pulumi.get(self, "access_log")


@pulumi.output_type
class VirtualGatewaySpecLoggingAccessLog(dict):
    def __init__(__self__, *,
                 file: Optional['outputs.VirtualGatewaySpecLoggingAccessLogFile'] = None):
        """
        :param 'VirtualGatewaySpecLoggingAccessLogFileArgs' file: The file object to send virtual gateway access logs to.
        """
        if file is not None:
            pulumi.set(__self__, "file", file)

    @property
    @pulumi.getter
    def file(self) -> Optional['outputs.VirtualGatewaySpecLoggingAccessLogFile']:
        """
        The file object to send virtual gateway access logs to.
        """
        return pulumi.get(self, "file")


@pulumi.output_type
class VirtualGatewaySpecLoggingAccessLogFile(dict):
    def __init__(__self__, *,
                 path: str):
        """
        :param str path: The file path to write access logs to. You can use `/dev/stdout` to send access logs to standard out. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def path(self) -> str:
        """
        The file path to write access logs to. You can use `/dev/stdout` to send access logs to standard out. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class VirtualNodeSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backendDefaults":
            suggest = "backend_defaults"
        elif key == "serviceDiscovery":
            suggest = "service_discovery"

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

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

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

    def __init__(__self__, *,
                 backend_defaults: Optional['outputs.VirtualNodeSpecBackendDefaults'] = None,
                 backends: Optional[Sequence['outputs.VirtualNodeSpecBackend']] = None,
                 listener: Optional['outputs.VirtualNodeSpecListener'] = None,
                 logging: Optional['outputs.VirtualNodeSpecLogging'] = None,
                 service_discovery: Optional['outputs.VirtualNodeSpecServiceDiscovery'] = None):
        """
        :param 'VirtualNodeSpecBackendDefaultsArgs' backend_defaults: The defaults for backends.
        :param Sequence['VirtualNodeSpecBackendArgs'] backends: The backends to which the virtual node is expected to send outbound traffic.
        :param 'VirtualNodeSpecListenerArgs' listener: The listeners from which the virtual node is expected to receive inbound traffic.
        :param 'VirtualNodeSpecLoggingArgs' logging: The inbound and outbound access logging information for the virtual node.
        :param 'VirtualNodeSpecServiceDiscoveryArgs' service_discovery: The service discovery information for the virtual node.
        """
        if backend_defaults is not None:
            pulumi.set(__self__, "backend_defaults", backend_defaults)
        if backends is not None:
            pulumi.set(__self__, "backends", backends)
        if listener is not None:
            pulumi.set(__self__, "listener", listener)
        if logging is not None:
            pulumi.set(__self__, "logging", logging)
        if service_discovery is not None:
            pulumi.set(__self__, "service_discovery", service_discovery)

    @property
    @pulumi.getter(name="backendDefaults")
    def backend_defaults(self) -> Optional['outputs.VirtualNodeSpecBackendDefaults']:
        """
        The defaults for backends.
        """
        return pulumi.get(self, "backend_defaults")

    @property
    @pulumi.getter
    def backends(self) -> Optional[Sequence['outputs.VirtualNodeSpecBackend']]:
        """
        The backends to which the virtual node is expected to send outbound traffic.
        """
        return pulumi.get(self, "backends")

    @property
    @pulumi.getter
    def listener(self) -> Optional['outputs.VirtualNodeSpecListener']:
        """
        The listeners from which the virtual node is expected to receive inbound traffic.
        """
        return pulumi.get(self, "listener")

    @property
    @pulumi.getter
    def logging(self) -> Optional['outputs.VirtualNodeSpecLogging']:
        """
        The inbound and outbound access logging information for the virtual node.
        """
        return pulumi.get(self, "logging")

    @property
    @pulumi.getter(name="serviceDiscovery")
    def service_discovery(self) -> Optional['outputs.VirtualNodeSpecServiceDiscovery']:
        """
        The service discovery information for the virtual node.
        """
        return pulumi.get(self, "service_discovery")


@pulumi.output_type
class VirtualNodeSpecBackend(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "virtualService":
            suggest = "virtual_service"

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

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

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

    def __init__(__self__, *,
                 virtual_service: 'outputs.VirtualNodeSpecBackendVirtualService'):
        """
        :param 'VirtualNodeSpecBackendVirtualServiceArgs' virtual_service: Specifies a virtual service to use as a backend for a virtual node.
        """
        pulumi.set(__self__, "virtual_service", virtual_service)

    @property
    @pulumi.getter(name="virtualService")
    def virtual_service(self) -> 'outputs.VirtualNodeSpecBackendVirtualService':
        """
        Specifies a virtual service to use as a backend for a virtual node.
        """
        return pulumi.get(self, "virtual_service")


@pulumi.output_type
class VirtualNodeSpecBackendDefaults(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientPolicy":
            suggest = "client_policy"

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

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

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

    def __init__(__self__, *,
                 client_policy: Optional['outputs.VirtualNodeSpecBackendDefaultsClientPolicy'] = None):
        """
        :param 'VirtualNodeSpecBackendDefaultsClientPolicyArgs' client_policy: The default client policy for virtual service backends. See above for details.
        """
        if client_policy is not None:
            pulumi.set(__self__, "client_policy", client_policy)

    @property
    @pulumi.getter(name="clientPolicy")
    def client_policy(self) -> Optional['outputs.VirtualNodeSpecBackendDefaultsClientPolicy']:
        """
        The default client policy for virtual service backends. See above for details.
        """
        return pulumi.get(self, "client_policy")


@pulumi.output_type
class VirtualNodeSpecBackendDefaultsClientPolicy(dict):
    def __init__(__self__, *,
                 tls: Optional['outputs.VirtualNodeSpecBackendDefaultsClientPolicyTls'] = None):
        """
        :param 'VirtualNodeSpecBackendDefaultsClientPolicyTlsArgs' tls: The Transport Layer Security (TLS) client policy.
        """
        if tls is not None:
            pulumi.set(__self__, "tls", tls)

    @property
    @pulumi.getter
    def tls(self) -> Optional['outputs.VirtualNodeSpecBackendDefaultsClientPolicyTls']:
        """
        The Transport Layer Security (TLS) client policy.
        """
        return pulumi.get(self, "tls")


@pulumi.output_type
class VirtualNodeSpecBackendDefaultsClientPolicyTls(dict):
    def __init__(__self__, *,
                 validation: 'outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsValidation',
                 certificate: Optional['outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsCertificate'] = None,
                 enforce: Optional[bool] = None,
                 ports: Optional[Sequence[int]] = None):
        """
        :param 'VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationArgs' validation: The listener's Transport Layer Security (TLS) validation context.
        :param 'VirtualNodeSpecBackendDefaultsClientPolicyTlsCertificateArgs' certificate: The listener's TLS certificate.
        :param bool enforce: Whether the policy is enforced. Default is `true`.
        :param Sequence[int] ports: One or more ports that the policy is enforced for.
        """
        pulumi.set(__self__, "validation", validation)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if enforce is not None:
            pulumi.set(__self__, "enforce", enforce)
        if ports is not None:
            pulumi.set(__self__, "ports", ports)

    @property
    @pulumi.getter
    def validation(self) -> 'outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsValidation':
        """
        The listener's Transport Layer Security (TLS) validation context.
        """
        return pulumi.get(self, "validation")

    @property
    @pulumi.getter
    def certificate(self) -> Optional['outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsCertificate']:
        """
        The listener's TLS certificate.
        """
        return pulumi.get(self, "certificate")

    @property
    @pulumi.getter
    def enforce(self) -> Optional[bool]:
        """
        Whether the policy is enforced. Default is `true`.
        """
        return pulumi.get(self, "enforce")

    @property
    @pulumi.getter
    def ports(self) -> Optional[Sequence[int]]:
        """
        One or more ports that the policy is enforced for.
        """
        return pulumi.get(self, "ports")


@pulumi.output_type
class VirtualNodeSpecBackendDefaultsClientPolicyTlsCertificate(dict):
    def __init__(__self__, *,
                 file: Optional['outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsCertificateFile'] = None,
                 sds: Optional['outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsCertificateSds'] = None):
        """
        :param 'VirtualNodeSpecBackendDefaultsClientPolicyTlsCertificateFileArgs' file: A local file certificate.
        :param 'VirtualNodeSpecBackendDefaultsClientPolicyTlsCertificateSdsArgs' sds: A [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        if file is not None:
            pulumi.set(__self__, "file", file)
        if sds is not None:
            pulumi.set(__self__, "sds", sds)

    @property
    @pulumi.getter
    def file(self) -> Optional['outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsCertificateFile']:
        """
        A local file certificate.
        """
        return pulumi.get(self, "file")

    @property
    @pulumi.getter
    def sds(self) -> Optional['outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsCertificateSds']:
        """
        A [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        return pulumi.get(self, "sds")


@pulumi.output_type
class VirtualNodeSpecBackendDefaultsClientPolicyTlsCertificateFile(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certificateChain":
            suggest = "certificate_chain"
        elif key == "privateKey":
            suggest = "private_key"

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

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

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

    def __init__(__self__, *,
                 certificate_chain: str,
                 private_key: str):
        """
        :param str certificate_chain: The certificate trust chain for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        :param str private_key: The private key for a certificate stored on the file system of the virtual node that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "certificate_chain", certificate_chain)
        pulumi.set(__self__, "private_key", private_key)

    @property
    @pulumi.getter(name="certificateChain")
    def certificate_chain(self) -> str:
        """
        The certificate trust chain for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "certificate_chain")

    @property
    @pulumi.getter(name="privateKey")
    def private_key(self) -> str:
        """
        The private key for a certificate stored on the file system of the virtual node that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "private_key")


@pulumi.output_type
class VirtualNodeSpecBackendDefaultsClientPolicyTlsCertificateSds(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secretName":
            suggest = "secret_name"

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

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

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

    def __init__(__self__, *,
                 secret_name: str):
        """
        :param str secret_name: The name of the secret for a virtual node's Transport Layer Security (TLS) Secret Discovery Service validation context trust.
        """
        pulumi.set(__self__, "secret_name", secret_name)

    @property
    @pulumi.getter(name="secretName")
    def secret_name(self) -> str:
        """
        The name of the secret for a virtual node's Transport Layer Security (TLS) Secret Discovery Service validation context trust.
        """
        return pulumi.get(self, "secret_name")


@pulumi.output_type
class VirtualNodeSpecBackendDefaultsClientPolicyTlsValidation(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "subjectAlternativeNames":
            suggest = "subject_alternative_names"

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

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

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

    def __init__(__self__, *,
                 trust: 'outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrust',
                 subject_alternative_names: Optional['outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNames'] = None):
        """
        :param 'VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustArgs' trust: The TLS validation context trust.
        :param 'VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesArgs' subject_alternative_names: The SANs for a TLS validation context.
        """
        pulumi.set(__self__, "trust", trust)
        if subject_alternative_names is not None:
            pulumi.set(__self__, "subject_alternative_names", subject_alternative_names)

    @property
    @pulumi.getter
    def trust(self) -> 'outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrust':
        """
        The TLS validation context trust.
        """
        return pulumi.get(self, "trust")

    @property
    @pulumi.getter(name="subjectAlternativeNames")
    def subject_alternative_names(self) -> Optional['outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNames']:
        """
        The SANs for a TLS validation context.
        """
        return pulumi.get(self, "subject_alternative_names")


@pulumi.output_type
class VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNames(dict):
    def __init__(__self__, *,
                 match: 'outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatch'):
        """
        :param 'VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatchArgs' match: The criteria for determining a SAN's match.
        """
        pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def match(self) -> 'outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatch':
        """
        The criteria for determining a SAN's match.
        """
        return pulumi.get(self, "match")


@pulumi.output_type
class VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatch(dict):
    def __init__(__self__, *,
                 exacts: Sequence[str]):
        """
        :param Sequence[str] exacts: The values sent must match the specified values exactly.
        """
        pulumi.set(__self__, "exacts", exacts)

    @property
    @pulumi.getter
    def exacts(self) -> Sequence[str]:
        """
        The values sent must match the specified values exactly.
        """
        return pulumi.get(self, "exacts")


@pulumi.output_type
class VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrust(dict):
    def __init__(__self__, *,
                 acm: Optional['outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustAcm'] = None,
                 file: Optional['outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustFile'] = None,
                 sds: Optional['outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustSds'] = None):
        """
        :param 'VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustAcmArgs' acm: The TLS validation context trust for an AWS Certificate Manager (ACM) certificate.
        :param 'VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustFileArgs' file: The TLS validation context trust for a local file certificate.
        :param 'VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustSdsArgs' sds: The TLS validation context trust for a [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        if acm is not None:
            pulumi.set(__self__, "acm", acm)
        if file is not None:
            pulumi.set(__self__, "file", file)
        if sds is not None:
            pulumi.set(__self__, "sds", sds)

    @property
    @pulumi.getter
    def acm(self) -> Optional['outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustAcm']:
        """
        The TLS validation context trust for an AWS Certificate Manager (ACM) certificate.
        """
        return pulumi.get(self, "acm")

    @property
    @pulumi.getter
    def file(self) -> Optional['outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustFile']:
        """
        The TLS validation context trust for a local file certificate.
        """
        return pulumi.get(self, "file")

    @property
    @pulumi.getter
    def sds(self) -> Optional['outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustSds']:
        """
        The TLS validation context trust for a [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        return pulumi.get(self, "sds")


@pulumi.output_type
class VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustAcm(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certificateAuthorityArns":
            suggest = "certificate_authority_arns"

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

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

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

    def __init__(__self__, *,
                 certificate_authority_arns: Sequence[str]):
        """
        :param Sequence[str] certificate_authority_arns: One or more ACM Amazon Resource Name (ARN)s.
        """
        pulumi.set(__self__, "certificate_authority_arns", certificate_authority_arns)

    @property
    @pulumi.getter(name="certificateAuthorityArns")
    def certificate_authority_arns(self) -> Sequence[str]:
        """
        One or more ACM Amazon Resource Name (ARN)s.
        """
        return pulumi.get(self, "certificate_authority_arns")


@pulumi.output_type
class VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustFile(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certificateChain":
            suggest = "certificate_chain"

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

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

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

    def __init__(__self__, *,
                 certificate_chain: str):
        """
        :param str certificate_chain: The certificate trust chain for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "certificate_chain", certificate_chain)

    @property
    @pulumi.getter(name="certificateChain")
    def certificate_chain(self) -> str:
        """
        The certificate trust chain for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "certificate_chain")


@pulumi.output_type
class VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustSds(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secretName":
            suggest = "secret_name"

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

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

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

    def __init__(__self__, *,
                 secret_name: str):
        """
        :param str secret_name: The name of the secret for a virtual node's Transport Layer Security (TLS) Secret Discovery Service validation context trust.
        """
        pulumi.set(__self__, "secret_name", secret_name)

    @property
    @pulumi.getter(name="secretName")
    def secret_name(self) -> str:
        """
        The name of the secret for a virtual node's Transport Layer Security (TLS) Secret Discovery Service validation context trust.
        """
        return pulumi.get(self, "secret_name")


@pulumi.output_type
class VirtualNodeSpecBackendVirtualService(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "virtualServiceName":
            suggest = "virtual_service_name"
        elif key == "clientPolicy":
            suggest = "client_policy"

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

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

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

    def __init__(__self__, *,
                 virtual_service_name: str,
                 client_policy: Optional['outputs.VirtualNodeSpecBackendVirtualServiceClientPolicy'] = None):
        """
        :param str virtual_service_name: The name of the virtual service that is acting as a virtual node backend. Must be between 1 and 255 characters in length.
        :param 'VirtualNodeSpecBackendVirtualServiceClientPolicyArgs' client_policy: The client policy for the backend.
        """
        pulumi.set(__self__, "virtual_service_name", virtual_service_name)
        if client_policy is not None:
            pulumi.set(__self__, "client_policy", client_policy)

    @property
    @pulumi.getter(name="virtualServiceName")
    def virtual_service_name(self) -> str:
        """
        The name of the virtual service that is acting as a virtual node backend. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "virtual_service_name")

    @property
    @pulumi.getter(name="clientPolicy")
    def client_policy(self) -> Optional['outputs.VirtualNodeSpecBackendVirtualServiceClientPolicy']:
        """
        The client policy for the backend.
        """
        return pulumi.get(self, "client_policy")


@pulumi.output_type
class VirtualNodeSpecBackendVirtualServiceClientPolicy(dict):
    def __init__(__self__, *,
                 tls: Optional['outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTls'] = None):
        """
        :param 'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsArgs' tls: The Transport Layer Security (TLS) client policy.
        """
        if tls is not None:
            pulumi.set(__self__, "tls", tls)

    @property
    @pulumi.getter
    def tls(self) -> Optional['outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTls']:
        """
        The Transport Layer Security (TLS) client policy.
        """
        return pulumi.get(self, "tls")


@pulumi.output_type
class VirtualNodeSpecBackendVirtualServiceClientPolicyTls(dict):
    def __init__(__self__, *,
                 validation: 'outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidation',
                 certificate: Optional['outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsCertificate'] = None,
                 enforce: Optional[bool] = None,
                 ports: Optional[Sequence[int]] = None):
        """
        :param 'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationArgs' validation: The listener's Transport Layer Security (TLS) validation context.
        :param 'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsCertificateArgs' certificate: The listener's TLS certificate.
        :param bool enforce: Whether the policy is enforced. Default is `true`.
        :param Sequence[int] ports: One or more ports that the policy is enforced for.
        """
        pulumi.set(__self__, "validation", validation)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if enforce is not None:
            pulumi.set(__self__, "enforce", enforce)
        if ports is not None:
            pulumi.set(__self__, "ports", ports)

    @property
    @pulumi.getter
    def validation(self) -> 'outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidation':
        """
        The listener's Transport Layer Security (TLS) validation context.
        """
        return pulumi.get(self, "validation")

    @property
    @pulumi.getter
    def certificate(self) -> Optional['outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsCertificate']:
        """
        The listener's TLS certificate.
        """
        return pulumi.get(self, "certificate")

    @property
    @pulumi.getter
    def enforce(self) -> Optional[bool]:
        """
        Whether the policy is enforced. Default is `true`.
        """
        return pulumi.get(self, "enforce")

    @property
    @pulumi.getter
    def ports(self) -> Optional[Sequence[int]]:
        """
        One or more ports that the policy is enforced for.
        """
        return pulumi.get(self, "ports")


@pulumi.output_type
class VirtualNodeSpecBackendVirtualServiceClientPolicyTlsCertificate(dict):
    def __init__(__self__, *,
                 file: Optional['outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsCertificateFile'] = None,
                 sds: Optional['outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsCertificateSds'] = None):
        """
        :param 'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsCertificateFileArgs' file: A local file certificate.
        :param 'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsCertificateSdsArgs' sds: A [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        if file is not None:
            pulumi.set(__self__, "file", file)
        if sds is not None:
            pulumi.set(__self__, "sds", sds)

    @property
    @pulumi.getter
    def file(self) -> Optional['outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsCertificateFile']:
        """
        A local file certificate.
        """
        return pulumi.get(self, "file")

    @property
    @pulumi.getter
    def sds(self) -> Optional['outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsCertificateSds']:
        """
        A [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        return pulumi.get(self, "sds")


@pulumi.output_type
class VirtualNodeSpecBackendVirtualServiceClientPolicyTlsCertificateFile(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certificateChain":
            suggest = "certificate_chain"
        elif key == "privateKey":
            suggest = "private_key"

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

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

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

    def __init__(__self__, *,
                 certificate_chain: str,
                 private_key: str):
        """
        :param str certificate_chain: The certificate trust chain for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        :param str private_key: The private key for a certificate stored on the file system of the virtual node that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "certificate_chain", certificate_chain)
        pulumi.set(__self__, "private_key", private_key)

    @property
    @pulumi.getter(name="certificateChain")
    def certificate_chain(self) -> str:
        """
        The certificate trust chain for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "certificate_chain")

    @property
    @pulumi.getter(name="privateKey")
    def private_key(self) -> str:
        """
        The private key for a certificate stored on the file system of the virtual node that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "private_key")


@pulumi.output_type
class VirtualNodeSpecBackendVirtualServiceClientPolicyTlsCertificateSds(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secretName":
            suggest = "secret_name"

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

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

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

    def __init__(__self__, *,
                 secret_name: str):
        """
        :param str secret_name: The name of the secret for a virtual node's Transport Layer Security (TLS) Secret Discovery Service validation context trust.
        """
        pulumi.set(__self__, "secret_name", secret_name)

    @property
    @pulumi.getter(name="secretName")
    def secret_name(self) -> str:
        """
        The name of the secret for a virtual node's Transport Layer Security (TLS) Secret Discovery Service validation context trust.
        """
        return pulumi.get(self, "secret_name")


@pulumi.output_type
class VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidation(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "subjectAlternativeNames":
            suggest = "subject_alternative_names"

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

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

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

    def __init__(__self__, *,
                 trust: 'outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrust',
                 subject_alternative_names: Optional['outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationSubjectAlternativeNames'] = None):
        """
        :param 'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustArgs' trust: The TLS validation context trust.
        :param 'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesArgs' subject_alternative_names: The SANs for a TLS validation context.
        """
        pulumi.set(__self__, "trust", trust)
        if subject_alternative_names is not None:
            pulumi.set(__self__, "subject_alternative_names", subject_alternative_names)

    @property
    @pulumi.getter
    def trust(self) -> 'outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrust':
        """
        The TLS validation context trust.
        """
        return pulumi.get(self, "trust")

    @property
    @pulumi.getter(name="subjectAlternativeNames")
    def subject_alternative_names(self) -> Optional['outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationSubjectAlternativeNames']:
        """
        The SANs for a TLS validation context.
        """
        return pulumi.get(self, "subject_alternative_names")


@pulumi.output_type
class VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationSubjectAlternativeNames(dict):
    def __init__(__self__, *,
                 match: 'outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatch'):
        """
        :param 'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatchArgs' match: The criteria for determining a SAN's match.
        """
        pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def match(self) -> 'outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatch':
        """
        The criteria for determining a SAN's match.
        """
        return pulumi.get(self, "match")


@pulumi.output_type
class VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatch(dict):
    def __init__(__self__, *,
                 exacts: Sequence[str]):
        """
        :param Sequence[str] exacts: The values sent must match the specified values exactly.
        """
        pulumi.set(__self__, "exacts", exacts)

    @property
    @pulumi.getter
    def exacts(self) -> Sequence[str]:
        """
        The values sent must match the specified values exactly.
        """
        return pulumi.get(self, "exacts")


@pulumi.output_type
class VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrust(dict):
    def __init__(__self__, *,
                 acm: Optional['outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustAcm'] = None,
                 file: Optional['outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustFile'] = None,
                 sds: Optional['outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustSds'] = None):
        """
        :param 'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustAcmArgs' acm: The TLS validation context trust for an AWS Certificate Manager (ACM) certificate.
        :param 'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustFileArgs' file: The TLS validation context trust for a local file certificate.
        :param 'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustSdsArgs' sds: The TLS validation context trust for a [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        if acm is not None:
            pulumi.set(__self__, "acm", acm)
        if file is not None:
            pulumi.set(__self__, "file", file)
        if sds is not None:
            pulumi.set(__self__, "sds", sds)

    @property
    @pulumi.getter
    def acm(self) -> Optional['outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustAcm']:
        """
        The TLS validation context trust for an AWS Certificate Manager (ACM) certificate.
        """
        return pulumi.get(self, "acm")

    @property
    @pulumi.getter
    def file(self) -> Optional['outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustFile']:
        """
        The TLS validation context trust for a local file certificate.
        """
        return pulumi.get(self, "file")

    @property
    @pulumi.getter
    def sds(self) -> Optional['outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustSds']:
        """
        The TLS validation context trust for a [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        return pulumi.get(self, "sds")


@pulumi.output_type
class VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustAcm(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certificateAuthorityArns":
            suggest = "certificate_authority_arns"

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

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

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

    def __init__(__self__, *,
                 certificate_authority_arns: Sequence[str]):
        """
        :param Sequence[str] certificate_authority_arns: One or more ACM Amazon Resource Name (ARN)s.
        """
        pulumi.set(__self__, "certificate_authority_arns", certificate_authority_arns)

    @property
    @pulumi.getter(name="certificateAuthorityArns")
    def certificate_authority_arns(self) -> Sequence[str]:
        """
        One or more ACM Amazon Resource Name (ARN)s.
        """
        return pulumi.get(self, "certificate_authority_arns")


@pulumi.output_type
class VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustFile(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certificateChain":
            suggest = "certificate_chain"

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

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

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

    def __init__(__self__, *,
                 certificate_chain: str):
        """
        :param str certificate_chain: The certificate trust chain for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "certificate_chain", certificate_chain)

    @property
    @pulumi.getter(name="certificateChain")
    def certificate_chain(self) -> str:
        """
        The certificate trust chain for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "certificate_chain")


@pulumi.output_type
class VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustSds(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secretName":
            suggest = "secret_name"

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

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

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

    def __init__(__self__, *,
                 secret_name: str):
        """
        :param str secret_name: The name of the secret for a virtual node's Transport Layer Security (TLS) Secret Discovery Service validation context trust.
        """
        pulumi.set(__self__, "secret_name", secret_name)

    @property
    @pulumi.getter(name="secretName")
    def secret_name(self) -> str:
        """
        The name of the secret for a virtual node's Transport Layer Security (TLS) Secret Discovery Service validation context trust.
        """
        return pulumi.get(self, "secret_name")


@pulumi.output_type
class VirtualNodeSpecListener(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "portMapping":
            suggest = "port_mapping"
        elif key == "connectionPool":
            suggest = "connection_pool"
        elif key == "healthCheck":
            suggest = "health_check"
        elif key == "outlierDetection":
            suggest = "outlier_detection"

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

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

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

    def __init__(__self__, *,
                 port_mapping: 'outputs.VirtualNodeSpecListenerPortMapping',
                 connection_pool: Optional['outputs.VirtualNodeSpecListenerConnectionPool'] = None,
                 health_check: Optional['outputs.VirtualNodeSpecListenerHealthCheck'] = None,
                 outlier_detection: Optional['outputs.VirtualNodeSpecListenerOutlierDetection'] = None,
                 timeout: Optional['outputs.VirtualNodeSpecListenerTimeout'] = None,
                 tls: Optional['outputs.VirtualNodeSpecListenerTls'] = None):
        """
        :param 'VirtualNodeSpecListenerPortMappingArgs' port_mapping: The port mapping information for the listener.
        :param 'VirtualNodeSpecListenerConnectionPoolArgs' connection_pool: The connection pool information for the listener.
        :param 'VirtualNodeSpecListenerHealthCheckArgs' health_check: The health check information for the listener.
        :param 'VirtualNodeSpecListenerOutlierDetectionArgs' outlier_detection: The outlier detection information for the listener.
        :param 'VirtualNodeSpecListenerTimeoutArgs' timeout: Timeouts for different protocols.
        :param 'VirtualNodeSpecListenerTlsArgs' tls: The Transport Layer Security (TLS) properties for the listener
        """
        pulumi.set(__self__, "port_mapping", port_mapping)
        if connection_pool is not None:
            pulumi.set(__self__, "connection_pool", connection_pool)
        if health_check is not None:
            pulumi.set(__self__, "health_check", health_check)
        if outlier_detection is not None:
            pulumi.set(__self__, "outlier_detection", outlier_detection)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)
        if tls is not None:
            pulumi.set(__self__, "tls", tls)

    @property
    @pulumi.getter(name="portMapping")
    def port_mapping(self) -> 'outputs.VirtualNodeSpecListenerPortMapping':
        """
        The port mapping information for the listener.
        """
        return pulumi.get(self, "port_mapping")

    @property
    @pulumi.getter(name="connectionPool")
    def connection_pool(self) -> Optional['outputs.VirtualNodeSpecListenerConnectionPool']:
        """
        The connection pool information for the listener.
        """
        return pulumi.get(self, "connection_pool")

    @property
    @pulumi.getter(name="healthCheck")
    def health_check(self) -> Optional['outputs.VirtualNodeSpecListenerHealthCheck']:
        """
        The health check information for the listener.
        """
        return pulumi.get(self, "health_check")

    @property
    @pulumi.getter(name="outlierDetection")
    def outlier_detection(self) -> Optional['outputs.VirtualNodeSpecListenerOutlierDetection']:
        """
        The outlier detection information for the listener.
        """
        return pulumi.get(self, "outlier_detection")

    @property
    @pulumi.getter
    def timeout(self) -> Optional['outputs.VirtualNodeSpecListenerTimeout']:
        """
        Timeouts for different protocols.
        """
        return pulumi.get(self, "timeout")

    @property
    @pulumi.getter
    def tls(self) -> Optional['outputs.VirtualNodeSpecListenerTls']:
        """
        The Transport Layer Security (TLS) properties for the listener
        """
        return pulumi.get(self, "tls")


@pulumi.output_type
class VirtualNodeSpecListenerConnectionPool(dict):
    def __init__(__self__, *,
                 grpc: Optional['outputs.VirtualNodeSpecListenerConnectionPoolGrpc'] = None,
                 http: Optional['outputs.VirtualNodeSpecListenerConnectionPoolHttp'] = None,
                 http2: Optional['outputs.VirtualNodeSpecListenerConnectionPoolHttp2'] = None,
                 tcp: Optional['outputs.VirtualNodeSpecListenerConnectionPoolTcp'] = None):
        """
        :param 'VirtualNodeSpecListenerConnectionPoolGrpcArgs' grpc: Connection pool information for gRPC listeners.
        :param 'VirtualNodeSpecListenerConnectionPoolHttpArgs' http: Connection pool information for HTTP listeners.
        :param 'VirtualNodeSpecListenerConnectionPoolHttp2Args' http2: Connection pool information for HTTP2 listeners.
        :param 'VirtualNodeSpecListenerConnectionPoolTcpArgs' tcp: Connection pool information for TCP listeners.
        """
        if grpc is not None:
            pulumi.set(__self__, "grpc", grpc)
        if http is not None:
            pulumi.set(__self__, "http", http)
        if http2 is not None:
            pulumi.set(__self__, "http2", http2)
        if tcp is not None:
            pulumi.set(__self__, "tcp", tcp)

    @property
    @pulumi.getter
    def grpc(self) -> Optional['outputs.VirtualNodeSpecListenerConnectionPoolGrpc']:
        """
        Connection pool information for gRPC listeners.
        """
        return pulumi.get(self, "grpc")

    @property
    @pulumi.getter
    def http(self) -> Optional['outputs.VirtualNodeSpecListenerConnectionPoolHttp']:
        """
        Connection pool information for HTTP listeners.
        """
        return pulumi.get(self, "http")

    @property
    @pulumi.getter
    def http2(self) -> Optional['outputs.VirtualNodeSpecListenerConnectionPoolHttp2']:
        """
        Connection pool information for HTTP2 listeners.
        """
        return pulumi.get(self, "http2")

    @property
    @pulumi.getter
    def tcp(self) -> Optional['outputs.VirtualNodeSpecListenerConnectionPoolTcp']:
        """
        Connection pool information for TCP listeners.
        """
        return pulumi.get(self, "tcp")


@pulumi.output_type
class VirtualNodeSpecListenerConnectionPoolGrpc(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxRequests":
            suggest = "max_requests"

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

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

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

    def __init__(__self__, *,
                 max_requests: int):
        """
        :param int max_requests: Maximum number of inflight requests Envoy can concurrently support across hosts in upstream cluster. Minimum value of `1`.
        """
        pulumi.set(__self__, "max_requests", max_requests)

    @property
    @pulumi.getter(name="maxRequests")
    def max_requests(self) -> int:
        """
        Maximum number of inflight requests Envoy can concurrently support across hosts in upstream cluster. Minimum value of `1`.
        """
        return pulumi.get(self, "max_requests")


@pulumi.output_type
class VirtualNodeSpecListenerConnectionPoolHttp2(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxRequests":
            suggest = "max_requests"

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

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

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

    def __init__(__self__, *,
                 max_requests: int):
        """
        :param int max_requests: Maximum number of inflight requests Envoy can concurrently support across hosts in upstream cluster. Minimum value of `1`.
        """
        pulumi.set(__self__, "max_requests", max_requests)

    @property
    @pulumi.getter(name="maxRequests")
    def max_requests(self) -> int:
        """
        Maximum number of inflight requests Envoy can concurrently support across hosts in upstream cluster. Minimum value of `1`.
        """
        return pulumi.get(self, "max_requests")


@pulumi.output_type
class VirtualNodeSpecListenerConnectionPoolHttp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxConnections":
            suggest = "max_connections"
        elif key == "maxPendingRequests":
            suggest = "max_pending_requests"

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

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

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

    def __init__(__self__, *,
                 max_connections: int,
                 max_pending_requests: Optional[int] = None):
        """
        :param int max_connections: Maximum number of outbound TCP connections Envoy can establish concurrently with all hosts in upstream cluster. Minimum value of `1`.
        :param int max_pending_requests: Number of overflowing requests after `max_connections` Envoy will queue to upstream cluster. Minimum value of `1`.
        """
        pulumi.set(__self__, "max_connections", max_connections)
        if max_pending_requests is not None:
            pulumi.set(__self__, "max_pending_requests", max_pending_requests)

    @property
    @pulumi.getter(name="maxConnections")
    def max_connections(self) -> int:
        """
        Maximum number of outbound TCP connections Envoy can establish concurrently with all hosts in upstream cluster. Minimum value of `1`.
        """
        return pulumi.get(self, "max_connections")

    @property
    @pulumi.getter(name="maxPendingRequests")
    def max_pending_requests(self) -> Optional[int]:
        """
        Number of overflowing requests after `max_connections` Envoy will queue to upstream cluster. Minimum value of `1`.
        """
        return pulumi.get(self, "max_pending_requests")


@pulumi.output_type
class VirtualNodeSpecListenerConnectionPoolTcp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxConnections":
            suggest = "max_connections"

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

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

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

    def __init__(__self__, *,
                 max_connections: int):
        """
        :param int max_connections: Maximum number of outbound TCP connections Envoy can establish concurrently with all hosts in upstream cluster. Minimum value of `1`.
        """
        pulumi.set(__self__, "max_connections", max_connections)

    @property
    @pulumi.getter(name="maxConnections")
    def max_connections(self) -> int:
        """
        Maximum number of outbound TCP connections Envoy can establish concurrently with all hosts in upstream cluster. Minimum value of `1`.
        """
        return pulumi.get(self, "max_connections")


@pulumi.output_type
class VirtualNodeSpecListenerHealthCheck(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "healthyThreshold":
            suggest = "healthy_threshold"
        elif key == "intervalMillis":
            suggest = "interval_millis"
        elif key == "timeoutMillis":
            suggest = "timeout_millis"
        elif key == "unhealthyThreshold":
            suggest = "unhealthy_threshold"

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

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

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

    def __init__(__self__, *,
                 healthy_threshold: int,
                 interval_millis: int,
                 protocol: str,
                 timeout_millis: int,
                 unhealthy_threshold: int,
                 path: Optional[str] = None,
                 port: Optional[int] = None):
        """
        :param int healthy_threshold: The number of consecutive successful health checks that must occur before declaring listener healthy.
        :param int interval_millis: The time period in milliseconds between each health check execution.
        :param str protocol: The protocol for the health check request. Valid values are `http`, `http2`, `tcp` and `grpc`.
        :param int timeout_millis: The amount of time to wait when receiving a response from the health check, in milliseconds.
        :param int unhealthy_threshold: The number of consecutive failed health checks that must occur before declaring a virtual node unhealthy.
        :param str path: The destination path for the health check request. This is only required if the specified protocol is `http` or `http2`.
        :param int port: The destination port for the health check request. This port must match the port defined in the `port_mapping` for the listener.
        """
        pulumi.set(__self__, "healthy_threshold", healthy_threshold)
        pulumi.set(__self__, "interval_millis", interval_millis)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "timeout_millis", timeout_millis)
        pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if port is not None:
            pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter(name="healthyThreshold")
    def healthy_threshold(self) -> int:
        """
        The number of consecutive successful health checks that must occur before declaring listener healthy.
        """
        return pulumi.get(self, "healthy_threshold")

    @property
    @pulumi.getter(name="intervalMillis")
    def interval_millis(self) -> int:
        """
        The time period in milliseconds between each health check execution.
        """
        return pulumi.get(self, "interval_millis")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        The protocol for the health check request. Valid values are `http`, `http2`, `tcp` and `grpc`.
        """
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter(name="timeoutMillis")
    def timeout_millis(self) -> int:
        """
        The amount of time to wait when receiving a response from the health check, in milliseconds.
        """
        return pulumi.get(self, "timeout_millis")

    @property
    @pulumi.getter(name="unhealthyThreshold")
    def unhealthy_threshold(self) -> int:
        """
        The number of consecutive failed health checks that must occur before declaring a virtual node unhealthy.
        """
        return pulumi.get(self, "unhealthy_threshold")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        The destination path for the health check request. This is only required if the specified protocol is `http` or `http2`.
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        The destination port for the health check request. This port must match the port defined in the `port_mapping` for the listener.
        """
        return pulumi.get(self, "port")


@pulumi.output_type
class VirtualNodeSpecListenerOutlierDetection(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "baseEjectionDuration":
            suggest = "base_ejection_duration"
        elif key == "maxEjectionPercent":
            suggest = "max_ejection_percent"
        elif key == "maxServerErrors":
            suggest = "max_server_errors"

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

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

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

    def __init__(__self__, *,
                 base_ejection_duration: 'outputs.VirtualNodeSpecListenerOutlierDetectionBaseEjectionDuration',
                 interval: 'outputs.VirtualNodeSpecListenerOutlierDetectionInterval',
                 max_ejection_percent: int,
                 max_server_errors: int):
        """
        :param 'VirtualNodeSpecListenerOutlierDetectionBaseEjectionDurationArgs' base_ejection_duration: The base amount of time for which a host is ejected.
        :param 'VirtualNodeSpecListenerOutlierDetectionIntervalArgs' interval: The time interval between ejection sweep analysis.
        :param int max_ejection_percent: Maximum percentage of hosts in load balancing pool for upstream service that can be ejected. Will eject at least one host regardless of the value.
               Minimum value of `0`. Maximum value of `100`.
        :param int max_server_errors: Number of consecutive `5xx` errors required for ejection. Minimum value of `1`.
        """
        pulumi.set(__self__, "base_ejection_duration", base_ejection_duration)
        pulumi.set(__self__, "interval", interval)
        pulumi.set(__self__, "max_ejection_percent", max_ejection_percent)
        pulumi.set(__self__, "max_server_errors", max_server_errors)

    @property
    @pulumi.getter(name="baseEjectionDuration")
    def base_ejection_duration(self) -> 'outputs.VirtualNodeSpecListenerOutlierDetectionBaseEjectionDuration':
        """
        The base amount of time for which a host is ejected.
        """
        return pulumi.get(self, "base_ejection_duration")

    @property
    @pulumi.getter
    def interval(self) -> 'outputs.VirtualNodeSpecListenerOutlierDetectionInterval':
        """
        The time interval between ejection sweep analysis.
        """
        return pulumi.get(self, "interval")

    @property
    @pulumi.getter(name="maxEjectionPercent")
    def max_ejection_percent(self) -> int:
        """
        Maximum percentage of hosts in load balancing pool for upstream service that can be ejected. Will eject at least one host regardless of the value.
        Minimum value of `0`. Maximum value of `100`.
        """
        return pulumi.get(self, "max_ejection_percent")

    @property
    @pulumi.getter(name="maxServerErrors")
    def max_server_errors(self) -> int:
        """
        Number of consecutive `5xx` errors required for ejection. Minimum value of `1`.
        """
        return pulumi.get(self, "max_server_errors")


@pulumi.output_type
class VirtualNodeSpecListenerOutlierDetectionBaseEjectionDuration(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        """
        :param str unit: The unit of time. Valid values: `ms`, `s`.
        :param int value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class VirtualNodeSpecListenerOutlierDetectionInterval(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        """
        :param str unit: The unit of time. Valid values: `ms`, `s`.
        :param int value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class VirtualNodeSpecListenerPortMapping(dict):
    def __init__(__self__, *,
                 port: int,
                 protocol: str):
        """
        :param int port: The port used for the port mapping.
        :param str protocol: The protocol used for the port mapping. Valid values are `http`, `http2`, `tcp` and `grpc`.
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "protocol", protocol)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port used for the port mapping.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        The protocol used for the port mapping. Valid values are `http`, `http2`, `tcp` and `grpc`.
        """
        return pulumi.get(self, "protocol")


@pulumi.output_type
class VirtualNodeSpecListenerTimeout(dict):
    def __init__(__self__, *,
                 grpc: Optional['outputs.VirtualNodeSpecListenerTimeoutGrpc'] = None,
                 http: Optional['outputs.VirtualNodeSpecListenerTimeoutHttp'] = None,
                 http2: Optional['outputs.VirtualNodeSpecListenerTimeoutHttp2'] = None,
                 tcp: Optional['outputs.VirtualNodeSpecListenerTimeoutTcp'] = None):
        """
        :param 'VirtualNodeSpecListenerTimeoutGrpcArgs' grpc: Timeouts for gRPC listeners.
        :param 'VirtualNodeSpecListenerTimeoutHttpArgs' http: Timeouts for HTTP listeners.
        :param 'VirtualNodeSpecListenerTimeoutHttp2Args' http2: Timeouts for HTTP2 listeners.
        :param 'VirtualNodeSpecListenerTimeoutTcpArgs' tcp: Timeouts for TCP listeners.
        """
        if grpc is not None:
            pulumi.set(__self__, "grpc", grpc)
        if http is not None:
            pulumi.set(__self__, "http", http)
        if http2 is not None:
            pulumi.set(__self__, "http2", http2)
        if tcp is not None:
            pulumi.set(__self__, "tcp", tcp)

    @property
    @pulumi.getter
    def grpc(self) -> Optional['outputs.VirtualNodeSpecListenerTimeoutGrpc']:
        """
        Timeouts for gRPC listeners.
        """
        return pulumi.get(self, "grpc")

    @property
    @pulumi.getter
    def http(self) -> Optional['outputs.VirtualNodeSpecListenerTimeoutHttp']:
        """
        Timeouts for HTTP listeners.
        """
        return pulumi.get(self, "http")

    @property
    @pulumi.getter
    def http2(self) -> Optional['outputs.VirtualNodeSpecListenerTimeoutHttp2']:
        """
        Timeouts for HTTP2 listeners.
        """
        return pulumi.get(self, "http2")

    @property
    @pulumi.getter
    def tcp(self) -> Optional['outputs.VirtualNodeSpecListenerTimeoutTcp']:
        """
        Timeouts for TCP listeners.
        """
        return pulumi.get(self, "tcp")


@pulumi.output_type
class VirtualNodeSpecListenerTimeoutGrpc(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "perRequest":
            suggest = "per_request"

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

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

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

    def __init__(__self__, *,
                 idle: Optional['outputs.VirtualNodeSpecListenerTimeoutGrpcIdle'] = None,
                 per_request: Optional['outputs.VirtualNodeSpecListenerTimeoutGrpcPerRequest'] = None):
        """
        :param 'VirtualNodeSpecListenerTimeoutGrpcIdleArgs' idle: The idle timeout. An idle timeout bounds the amount of time that a connection may be idle.
        :param 'VirtualNodeSpecListenerTimeoutGrpcPerRequestArgs' per_request: The per request timeout.
        """
        if idle is not None:
            pulumi.set(__self__, "idle", idle)
        if per_request is not None:
            pulumi.set(__self__, "per_request", per_request)

    @property
    @pulumi.getter
    def idle(self) -> Optional['outputs.VirtualNodeSpecListenerTimeoutGrpcIdle']:
        """
        The idle timeout. An idle timeout bounds the amount of time that a connection may be idle.
        """
        return pulumi.get(self, "idle")

    @property
    @pulumi.getter(name="perRequest")
    def per_request(self) -> Optional['outputs.VirtualNodeSpecListenerTimeoutGrpcPerRequest']:
        """
        The per request timeout.
        """
        return pulumi.get(self, "per_request")


@pulumi.output_type
class VirtualNodeSpecListenerTimeoutGrpcIdle(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        """
        :param str unit: The unit of time. Valid values: `ms`, `s`.
        :param int value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class VirtualNodeSpecListenerTimeoutGrpcPerRequest(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        """
        :param str unit: The unit of time. Valid values: `ms`, `s`.
        :param int value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class VirtualNodeSpecListenerTimeoutHttp2(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "perRequest":
            suggest = "per_request"

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

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

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

    def __init__(__self__, *,
                 idle: Optional['outputs.VirtualNodeSpecListenerTimeoutHttp2Idle'] = None,
                 per_request: Optional['outputs.VirtualNodeSpecListenerTimeoutHttp2PerRequest'] = None):
        """
        :param 'VirtualNodeSpecListenerTimeoutHttp2IdleArgs' idle: The idle timeout. An idle timeout bounds the amount of time that a connection may be idle.
        :param 'VirtualNodeSpecListenerTimeoutHttp2PerRequestArgs' per_request: The per request timeout.
        """
        if idle is not None:
            pulumi.set(__self__, "idle", idle)
        if per_request is not None:
            pulumi.set(__self__, "per_request", per_request)

    @property
    @pulumi.getter
    def idle(self) -> Optional['outputs.VirtualNodeSpecListenerTimeoutHttp2Idle']:
        """
        The idle timeout. An idle timeout bounds the amount of time that a connection may be idle.
        """
        return pulumi.get(self, "idle")

    @property
    @pulumi.getter(name="perRequest")
    def per_request(self) -> Optional['outputs.VirtualNodeSpecListenerTimeoutHttp2PerRequest']:
        """
        The per request timeout.
        """
        return pulumi.get(self, "per_request")


@pulumi.output_type
class VirtualNodeSpecListenerTimeoutHttp2Idle(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        """
        :param str unit: The unit of time. Valid values: `ms`, `s`.
        :param int value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class VirtualNodeSpecListenerTimeoutHttp2PerRequest(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        """
        :param str unit: The unit of time. Valid values: `ms`, `s`.
        :param int value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class VirtualNodeSpecListenerTimeoutHttp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "perRequest":
            suggest = "per_request"

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

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

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

    def __init__(__self__, *,
                 idle: Optional['outputs.VirtualNodeSpecListenerTimeoutHttpIdle'] = None,
                 per_request: Optional['outputs.VirtualNodeSpecListenerTimeoutHttpPerRequest'] = None):
        """
        :param 'VirtualNodeSpecListenerTimeoutHttpIdleArgs' idle: The idle timeout. An idle timeout bounds the amount of time that a connection may be idle.
        :param 'VirtualNodeSpecListenerTimeoutHttpPerRequestArgs' per_request: The per request timeout.
        """
        if idle is not None:
            pulumi.set(__self__, "idle", idle)
        if per_request is not None:
            pulumi.set(__self__, "per_request", per_request)

    @property
    @pulumi.getter
    def idle(self) -> Optional['outputs.VirtualNodeSpecListenerTimeoutHttpIdle']:
        """
        The idle timeout. An idle timeout bounds the amount of time that a connection may be idle.
        """
        return pulumi.get(self, "idle")

    @property
    @pulumi.getter(name="perRequest")
    def per_request(self) -> Optional['outputs.VirtualNodeSpecListenerTimeoutHttpPerRequest']:
        """
        The per request timeout.
        """
        return pulumi.get(self, "per_request")


@pulumi.output_type
class VirtualNodeSpecListenerTimeoutHttpIdle(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        """
        :param str unit: The unit of time. Valid values: `ms`, `s`.
        :param int value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class VirtualNodeSpecListenerTimeoutHttpPerRequest(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        """
        :param str unit: The unit of time. Valid values: `ms`, `s`.
        :param int value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class VirtualNodeSpecListenerTimeoutTcp(dict):
    def __init__(__self__, *,
                 idle: Optional['outputs.VirtualNodeSpecListenerTimeoutTcpIdle'] = None):
        """
        :param 'VirtualNodeSpecListenerTimeoutTcpIdleArgs' idle: The idle timeout. An idle timeout bounds the amount of time that a connection may be idle.
        """
        if idle is not None:
            pulumi.set(__self__, "idle", idle)

    @property
    @pulumi.getter
    def idle(self) -> Optional['outputs.VirtualNodeSpecListenerTimeoutTcpIdle']:
        """
        The idle timeout. An idle timeout bounds the amount of time that a connection may be idle.
        """
        return pulumi.get(self, "idle")


@pulumi.output_type
class VirtualNodeSpecListenerTimeoutTcpIdle(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        """
        :param str unit: The unit of time. Valid values: `ms`, `s`.
        :param int value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class VirtualNodeSpecListenerTls(dict):
    def __init__(__self__, *,
                 certificate: 'outputs.VirtualNodeSpecListenerTlsCertificate',
                 mode: str,
                 validation: Optional['outputs.VirtualNodeSpecListenerTlsValidation'] = None):
        """
        :param 'VirtualNodeSpecListenerTlsCertificateArgs' certificate: The listener's TLS certificate.
        :param str mode: The listener's TLS mode. Valid values: `DISABLED`, `PERMISSIVE`, `STRICT`.
        :param 'VirtualNodeSpecListenerTlsValidationArgs' validation: The listener's Transport Layer Security (TLS) validation context.
        """
        pulumi.set(__self__, "certificate", certificate)
        pulumi.set(__self__, "mode", mode)
        if validation is not None:
            pulumi.set(__self__, "validation", validation)

    @property
    @pulumi.getter
    def certificate(self) -> 'outputs.VirtualNodeSpecListenerTlsCertificate':
        """
        The listener's TLS certificate.
        """
        return pulumi.get(self, "certificate")

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        The listener's TLS mode. Valid values: `DISABLED`, `PERMISSIVE`, `STRICT`.
        """
        return pulumi.get(self, "mode")

    @property
    @pulumi.getter
    def validation(self) -> Optional['outputs.VirtualNodeSpecListenerTlsValidation']:
        """
        The listener's Transport Layer Security (TLS) validation context.
        """
        return pulumi.get(self, "validation")


@pulumi.output_type
class VirtualNodeSpecListenerTlsCertificate(dict):
    def __init__(__self__, *,
                 acm: Optional['outputs.VirtualNodeSpecListenerTlsCertificateAcm'] = None,
                 file: Optional['outputs.VirtualNodeSpecListenerTlsCertificateFile'] = None,
                 sds: Optional['outputs.VirtualNodeSpecListenerTlsCertificateSds'] = None):
        """
        :param 'VirtualNodeSpecListenerTlsCertificateAcmArgs' acm: An AWS Certificate Manager (ACM) certificate.
        :param 'VirtualNodeSpecListenerTlsCertificateFileArgs' file: A local file certificate.
        :param 'VirtualNodeSpecListenerTlsCertificateSdsArgs' sds: A [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        if acm is not None:
            pulumi.set(__self__, "acm", acm)
        if file is not None:
            pulumi.set(__self__, "file", file)
        if sds is not None:
            pulumi.set(__self__, "sds", sds)

    @property
    @pulumi.getter
    def acm(self) -> Optional['outputs.VirtualNodeSpecListenerTlsCertificateAcm']:
        """
        An AWS Certificate Manager (ACM) certificate.
        """
        return pulumi.get(self, "acm")

    @property
    @pulumi.getter
    def file(self) -> Optional['outputs.VirtualNodeSpecListenerTlsCertificateFile']:
        """
        A local file certificate.
        """
        return pulumi.get(self, "file")

    @property
    @pulumi.getter
    def sds(self) -> Optional['outputs.VirtualNodeSpecListenerTlsCertificateSds']:
        """
        A [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        return pulumi.get(self, "sds")


@pulumi.output_type
class VirtualNodeSpecListenerTlsCertificateAcm(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certificateArn":
            suggest = "certificate_arn"

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

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

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

    def __init__(__self__, *,
                 certificate_arn: str):
        """
        :param str certificate_arn: The Amazon Resource Name (ARN) for the certificate.
        """
        pulumi.set(__self__, "certificate_arn", certificate_arn)

    @property
    @pulumi.getter(name="certificateArn")
    def certificate_arn(self) -> str:
        """
        The Amazon Resource Name (ARN) for the certificate.
        """
        return pulumi.get(self, "certificate_arn")


@pulumi.output_type
class VirtualNodeSpecListenerTlsCertificateFile(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certificateChain":
            suggest = "certificate_chain"
        elif key == "privateKey":
            suggest = "private_key"

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

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

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

    def __init__(__self__, *,
                 certificate_chain: str,
                 private_key: str):
        """
        :param str certificate_chain: The certificate trust chain for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        :param str private_key: The private key for a certificate stored on the file system of the virtual node that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "certificate_chain", certificate_chain)
        pulumi.set(__self__, "private_key", private_key)

    @property
    @pulumi.getter(name="certificateChain")
    def certificate_chain(self) -> str:
        """
        The certificate trust chain for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "certificate_chain")

    @property
    @pulumi.getter(name="privateKey")
    def private_key(self) -> str:
        """
        The private key for a certificate stored on the file system of the virtual node that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "private_key")


@pulumi.output_type
class VirtualNodeSpecListenerTlsCertificateSds(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secretName":
            suggest = "secret_name"

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

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

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

    def __init__(__self__, *,
                 secret_name: str):
        """
        :param str secret_name: The name of the secret for a virtual node's Transport Layer Security (TLS) Secret Discovery Service validation context trust.
        """
        pulumi.set(__self__, "secret_name", secret_name)

    @property
    @pulumi.getter(name="secretName")
    def secret_name(self) -> str:
        """
        The name of the secret for a virtual node's Transport Layer Security (TLS) Secret Discovery Service validation context trust.
        """
        return pulumi.get(self, "secret_name")


@pulumi.output_type
class VirtualNodeSpecListenerTlsValidation(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "subjectAlternativeNames":
            suggest = "subject_alternative_names"

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

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

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

    def __init__(__self__, *,
                 trust: 'outputs.VirtualNodeSpecListenerTlsValidationTrust',
                 subject_alternative_names: Optional['outputs.VirtualNodeSpecListenerTlsValidationSubjectAlternativeNames'] = None):
        """
        :param 'VirtualNodeSpecListenerTlsValidationTrustArgs' trust: The TLS validation context trust.
        :param 'VirtualNodeSpecListenerTlsValidationSubjectAlternativeNamesArgs' subject_alternative_names: The SANs for a TLS validation context.
        """
        pulumi.set(__self__, "trust", trust)
        if subject_alternative_names is not None:
            pulumi.set(__self__, "subject_alternative_names", subject_alternative_names)

    @property
    @pulumi.getter
    def trust(self) -> 'outputs.VirtualNodeSpecListenerTlsValidationTrust':
        """
        The TLS validation context trust.
        """
        return pulumi.get(self, "trust")

    @property
    @pulumi.getter(name="subjectAlternativeNames")
    def subject_alternative_names(self) -> Optional['outputs.VirtualNodeSpecListenerTlsValidationSubjectAlternativeNames']:
        """
        The SANs for a TLS validation context.
        """
        return pulumi.get(self, "subject_alternative_names")


@pulumi.output_type
class VirtualNodeSpecListenerTlsValidationSubjectAlternativeNames(dict):
    def __init__(__self__, *,
                 match: 'outputs.VirtualNodeSpecListenerTlsValidationSubjectAlternativeNamesMatch'):
        """
        :param 'VirtualNodeSpecListenerTlsValidationSubjectAlternativeNamesMatchArgs' match: The criteria for determining a SAN's match.
        """
        pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def match(self) -> 'outputs.VirtualNodeSpecListenerTlsValidationSubjectAlternativeNamesMatch':
        """
        The criteria for determining a SAN's match.
        """
        return pulumi.get(self, "match")


@pulumi.output_type
class VirtualNodeSpecListenerTlsValidationSubjectAlternativeNamesMatch(dict):
    def __init__(__self__, *,
                 exacts: Sequence[str]):
        """
        :param Sequence[str] exacts: The values sent must match the specified values exactly.
        """
        pulumi.set(__self__, "exacts", exacts)

    @property
    @pulumi.getter
    def exacts(self) -> Sequence[str]:
        """
        The values sent must match the specified values exactly.
        """
        return pulumi.get(self, "exacts")


@pulumi.output_type
class VirtualNodeSpecListenerTlsValidationTrust(dict):
    def __init__(__self__, *,
                 file: Optional['outputs.VirtualNodeSpecListenerTlsValidationTrustFile'] = None,
                 sds: Optional['outputs.VirtualNodeSpecListenerTlsValidationTrustSds'] = None):
        """
        :param 'VirtualNodeSpecListenerTlsValidationTrustFileArgs' file: The TLS validation context trust for a local file certificate.
        :param 'VirtualNodeSpecListenerTlsValidationTrustSdsArgs' sds: The TLS validation context trust for a [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        if file is not None:
            pulumi.set(__self__, "file", file)
        if sds is not None:
            pulumi.set(__self__, "sds", sds)

    @property
    @pulumi.getter
    def file(self) -> Optional['outputs.VirtualNodeSpecListenerTlsValidationTrustFile']:
        """
        The TLS validation context trust for a local file certificate.
        """
        return pulumi.get(self, "file")

    @property
    @pulumi.getter
    def sds(self) -> Optional['outputs.VirtualNodeSpecListenerTlsValidationTrustSds']:
        """
        The TLS validation context trust for a [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        return pulumi.get(self, "sds")


@pulumi.output_type
class VirtualNodeSpecListenerTlsValidationTrustFile(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certificateChain":
            suggest = "certificate_chain"

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

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

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

    def __init__(__self__, *,
                 certificate_chain: str):
        """
        :param str certificate_chain: The certificate trust chain for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "certificate_chain", certificate_chain)

    @property
    @pulumi.getter(name="certificateChain")
    def certificate_chain(self) -> str:
        """
        The certificate trust chain for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "certificate_chain")


@pulumi.output_type
class VirtualNodeSpecListenerTlsValidationTrustSds(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secretName":
            suggest = "secret_name"

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

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

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

    def __init__(__self__, *,
                 secret_name: str):
        """
        :param str secret_name: The name of the secret for a virtual node's Transport Layer Security (TLS) Secret Discovery Service validation context trust.
        """
        pulumi.set(__self__, "secret_name", secret_name)

    @property
    @pulumi.getter(name="secretName")
    def secret_name(self) -> str:
        """
        The name of the secret for a virtual node's Transport Layer Security (TLS) Secret Discovery Service validation context trust.
        """
        return pulumi.get(self, "secret_name")


@pulumi.output_type
class VirtualNodeSpecLogging(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessLog":
            suggest = "access_log"

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

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

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

    def __init__(__self__, *,
                 access_log: Optional['outputs.VirtualNodeSpecLoggingAccessLog'] = None):
        """
        :param 'VirtualNodeSpecLoggingAccessLogArgs' access_log: The access log configuration for a virtual node.
        """
        if access_log is not None:
            pulumi.set(__self__, "access_log", access_log)

    @property
    @pulumi.getter(name="accessLog")
    def access_log(self) -> Optional['outputs.VirtualNodeSpecLoggingAccessLog']:
        """
        The access log configuration for a virtual node.
        """
        return pulumi.get(self, "access_log")


@pulumi.output_type
class VirtualNodeSpecLoggingAccessLog(dict):
    def __init__(__self__, *,
                 file: Optional['outputs.VirtualNodeSpecLoggingAccessLogFile'] = None):
        """
        :param 'VirtualNodeSpecLoggingAccessLogFileArgs' file: The file object to send virtual node access logs to.
        """
        if file is not None:
            pulumi.set(__self__, "file", file)

    @property
    @pulumi.getter
    def file(self) -> Optional['outputs.VirtualNodeSpecLoggingAccessLogFile']:
        """
        The file object to send virtual node access logs to.
        """
        return pulumi.get(self, "file")


@pulumi.output_type
class VirtualNodeSpecLoggingAccessLogFile(dict):
    def __init__(__self__, *,
                 path: str):
        """
        :param str path: The file path to write access logs to. You can use `/dev/stdout` to send access logs to standard out. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def path(self) -> str:
        """
        The file path to write access logs to. You can use `/dev/stdout` to send access logs to standard out. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class VirtualNodeSpecServiceDiscovery(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "awsCloudMap":
            suggest = "aws_cloud_map"

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

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

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

    def __init__(__self__, *,
                 aws_cloud_map: Optional['outputs.VirtualNodeSpecServiceDiscoveryAwsCloudMap'] = None,
                 dns: Optional['outputs.VirtualNodeSpecServiceDiscoveryDns'] = None):
        """
        :param 'VirtualNodeSpecServiceDiscoveryAwsCloudMapArgs' aws_cloud_map: Specifies any AWS Cloud Map information for the virtual node.
        :param 'VirtualNodeSpecServiceDiscoveryDnsArgs' dns: Specifies the DNS service name for the virtual node.
        """
        if aws_cloud_map is not None:
            pulumi.set(__self__, "aws_cloud_map", aws_cloud_map)
        if dns is not None:
            pulumi.set(__self__, "dns", dns)

    @property
    @pulumi.getter(name="awsCloudMap")
    def aws_cloud_map(self) -> Optional['outputs.VirtualNodeSpecServiceDiscoveryAwsCloudMap']:
        """
        Specifies any AWS Cloud Map information for the virtual node.
        """
        return pulumi.get(self, "aws_cloud_map")

    @property
    @pulumi.getter
    def dns(self) -> Optional['outputs.VirtualNodeSpecServiceDiscoveryDns']:
        """
        Specifies the DNS service name for the virtual node.
        """
        return pulumi.get(self, "dns")


@pulumi.output_type
class VirtualNodeSpecServiceDiscoveryAwsCloudMap(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "namespaceName":
            suggest = "namespace_name"
        elif key == "serviceName":
            suggest = "service_name"

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

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

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

    def __init__(__self__, *,
                 namespace_name: str,
                 service_name: str,
                 attributes: Optional[Mapping[str, str]] = None):
        """
        :param str namespace_name: The name of the AWS Cloud Map namespace to use.
               Use the `servicediscovery.HttpNamespace` resource to configure a Cloud Map namespace. Must be between 1 and 1024 characters in length.
        :param str service_name: The name of the AWS Cloud Map service to use. Use the `servicediscovery.Service` resource to configure a Cloud Map service. Must be between 1 and 1024 characters in length.
        :param Mapping[str, str] attributes: A string map that contains attributes with values that you can use to filter instances by any custom attribute that you specified when you registered the instance. Only instances that match all of the specified key/value pairs will be returned.
        """
        pulumi.set(__self__, "namespace_name", namespace_name)
        pulumi.set(__self__, "service_name", service_name)
        if attributes is not None:
            pulumi.set(__self__, "attributes", attributes)

    @property
    @pulumi.getter(name="namespaceName")
    def namespace_name(self) -> str:
        """
        The name of the AWS Cloud Map namespace to use.
        Use the `servicediscovery.HttpNamespace` resource to configure a Cloud Map namespace. Must be between 1 and 1024 characters in length.
        """
        return pulumi.get(self, "namespace_name")

    @property
    @pulumi.getter(name="serviceName")
    def service_name(self) -> str:
        """
        The name of the AWS Cloud Map service to use. Use the `servicediscovery.Service` resource to configure a Cloud Map service. Must be between 1 and 1024 characters in length.
        """
        return pulumi.get(self, "service_name")

    @property
    @pulumi.getter
    def attributes(self) -> Optional[Mapping[str, str]]:
        """
        A string map that contains attributes with values that you can use to filter instances by any custom attribute that you specified when you registered the instance. Only instances that match all of the specified key/value pairs will be returned.
        """
        return pulumi.get(self, "attributes")


@pulumi.output_type
class VirtualNodeSpecServiceDiscoveryDns(dict):
    def __init__(__self__, *,
                 hostname: str):
        """
        :param str hostname: The DNS host name for your virtual node.
        """
        pulumi.set(__self__, "hostname", hostname)

    @property
    @pulumi.getter
    def hostname(self) -> str:
        """
        The DNS host name for your virtual node.
        """
        return pulumi.get(self, "hostname")


@pulumi.output_type
class VirtualRouterSpec(dict):
    def __init__(__self__, *,
                 listener: 'outputs.VirtualRouterSpecListener'):
        """
        :param 'VirtualRouterSpecListenerArgs' listener: The listeners that the virtual router is expected to receive inbound traffic from.
               Currently only one listener is supported per virtual router.
        """
        pulumi.set(__self__, "listener", listener)

    @property
    @pulumi.getter
    def listener(self) -> 'outputs.VirtualRouterSpecListener':
        """
        The listeners that the virtual router is expected to receive inbound traffic from.
        Currently only one listener is supported per virtual router.
        """
        return pulumi.get(self, "listener")


@pulumi.output_type
class VirtualRouterSpecListener(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "portMapping":
            suggest = "port_mapping"

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

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

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

    def __init__(__self__, *,
                 port_mapping: 'outputs.VirtualRouterSpecListenerPortMapping'):
        """
        :param 'VirtualRouterSpecListenerPortMappingArgs' port_mapping: The port mapping information for the listener.
        """
        pulumi.set(__self__, "port_mapping", port_mapping)

    @property
    @pulumi.getter(name="portMapping")
    def port_mapping(self) -> 'outputs.VirtualRouterSpecListenerPortMapping':
        """
        The port mapping information for the listener.
        """
        return pulumi.get(self, "port_mapping")


@pulumi.output_type
class VirtualRouterSpecListenerPortMapping(dict):
    def __init__(__self__, *,
                 port: int,
                 protocol: str):
        """
        :param int port: The port used for the port mapping.
        :param str protocol: The protocol used for the port mapping. Valid values are `http`,`http2`, `tcp` and `grpc`.
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "protocol", protocol)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port used for the port mapping.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        The protocol used for the port mapping. Valid values are `http`,`http2`, `tcp` and `grpc`.
        """
        return pulumi.get(self, "protocol")


@pulumi.output_type
class VirtualServiceSpec(dict):
    def __init__(__self__, *,
                 provider: Optional['outputs.VirtualServiceSpecProvider'] = None):
        """
        :param 'VirtualServiceSpecProviderArgs' provider: The App Mesh object that is acting as the provider for a virtual service. You can specify a single virtual node or virtual router.
        """
        if provider is not None:
            pulumi.set(__self__, "provider", provider)

    @property
    @pulumi.getter
    def provider(self) -> Optional['outputs.VirtualServiceSpecProvider']:
        """
        The App Mesh object that is acting as the provider for a virtual service. You can specify a single virtual node or virtual router.
        """
        return pulumi.get(self, "provider")


@pulumi.output_type
class VirtualServiceSpecProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "virtualNode":
            suggest = "virtual_node"
        elif key == "virtualRouter":
            suggest = "virtual_router"

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

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

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

    def __init__(__self__, *,
                 virtual_node: Optional['outputs.VirtualServiceSpecProviderVirtualNode'] = None,
                 virtual_router: Optional['outputs.VirtualServiceSpecProviderVirtualRouter'] = None):
        """
        :param 'VirtualServiceSpecProviderVirtualNodeArgs' virtual_node: The virtual node associated with a virtual service.
        :param 'VirtualServiceSpecProviderVirtualRouterArgs' virtual_router: The virtual router associated with a virtual service.
        """
        if virtual_node is not None:
            pulumi.set(__self__, "virtual_node", virtual_node)
        if virtual_router is not None:
            pulumi.set(__self__, "virtual_router", virtual_router)

    @property
    @pulumi.getter(name="virtualNode")
    def virtual_node(self) -> Optional['outputs.VirtualServiceSpecProviderVirtualNode']:
        """
        The virtual node associated with a virtual service.
        """
        return pulumi.get(self, "virtual_node")

    @property
    @pulumi.getter(name="virtualRouter")
    def virtual_router(self) -> Optional['outputs.VirtualServiceSpecProviderVirtualRouter']:
        """
        The virtual router associated with a virtual service.
        """
        return pulumi.get(self, "virtual_router")


@pulumi.output_type
class VirtualServiceSpecProviderVirtualNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "virtualNodeName":
            suggest = "virtual_node_name"

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

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

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

    def __init__(__self__, *,
                 virtual_node_name: str):
        """
        :param str virtual_node_name: The name of the virtual node that is acting as a service provider. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "virtual_node_name", virtual_node_name)

    @property
    @pulumi.getter(name="virtualNodeName")
    def virtual_node_name(self) -> str:
        """
        The name of the virtual node that is acting as a service provider. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "virtual_node_name")


@pulumi.output_type
class VirtualServiceSpecProviderVirtualRouter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "virtualRouterName":
            suggest = "virtual_router_name"

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

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

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

    def __init__(__self__, *,
                 virtual_router_name: str):
        """
        :param str virtual_router_name: The name of the virtual router that is acting as a service provider. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "virtual_router_name", virtual_router_name)

    @property
    @pulumi.getter(name="virtualRouterName")
    def virtual_router_name(self) -> str:
        """
        The name of the virtual router that is acting as a service provider. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "virtual_router_name")


@pulumi.output_type
class GetMeshSpecResult(dict):
    def __init__(__self__, *,
                 egress_filters: Sequence['outputs.GetMeshSpecEgressFilterResult']):
        """
        :param Sequence['GetMeshSpecEgressFilterArgs'] egress_filters: The egress filter rules for the service mesh.
        """
        pulumi.set(__self__, "egress_filters", egress_filters)

    @property
    @pulumi.getter(name="egressFilters")
    def egress_filters(self) -> Sequence['outputs.GetMeshSpecEgressFilterResult']:
        """
        The egress filter rules for the service mesh.
        """
        return pulumi.get(self, "egress_filters")


@pulumi.output_type
class GetMeshSpecEgressFilterResult(dict):
    def __init__(__self__, *,
                 type: str):
        """
        :param str type: The egress filter type.
        """
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The egress filter type.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetVirtualServiceSpecResult(dict):
    def __init__(__self__, *,
                 providers: Sequence['outputs.GetVirtualServiceSpecProviderResult']):
        """
        :param Sequence['GetVirtualServiceSpecProviderArgs'] providers: The App Mesh object that is acting as the provider for a virtual service.
        """
        pulumi.set(__self__, "providers", providers)

    @property
    @pulumi.getter
    def providers(self) -> Sequence['outputs.GetVirtualServiceSpecProviderResult']:
        """
        The App Mesh object that is acting as the provider for a virtual service.
        """
        return pulumi.get(self, "providers")


@pulumi.output_type
class GetVirtualServiceSpecProviderResult(dict):
    def __init__(__self__, *,
                 virtual_nodes: Sequence['outputs.GetVirtualServiceSpecProviderVirtualNodeResult'],
                 virtual_routers: Sequence['outputs.GetVirtualServiceSpecProviderVirtualRouterResult']):
        """
        :param Sequence['GetVirtualServiceSpecProviderVirtualNodeArgs'] virtual_nodes: The virtual node associated with the virtual service.
        :param Sequence['GetVirtualServiceSpecProviderVirtualRouterArgs'] virtual_routers: The virtual router associated with the virtual service.
        """
        pulumi.set(__self__, "virtual_nodes", virtual_nodes)
        pulumi.set(__self__, "virtual_routers", virtual_routers)

    @property
    @pulumi.getter(name="virtualNodes")
    def virtual_nodes(self) -> Sequence['outputs.GetVirtualServiceSpecProviderVirtualNodeResult']:
        """
        The virtual node associated with the virtual service.
        """
        return pulumi.get(self, "virtual_nodes")

    @property
    @pulumi.getter(name="virtualRouters")
    def virtual_routers(self) -> Sequence['outputs.GetVirtualServiceSpecProviderVirtualRouterResult']:
        """
        The virtual router associated with the virtual service.
        """
        return pulumi.get(self, "virtual_routers")


@pulumi.output_type
class GetVirtualServiceSpecProviderVirtualNodeResult(dict):
    def __init__(__self__, *,
                 virtual_node_name: str):
        """
        :param str virtual_node_name: The name of the virtual node that is acting as a service provider.
        """
        pulumi.set(__self__, "virtual_node_name", virtual_node_name)

    @property
    @pulumi.getter(name="virtualNodeName")
    def virtual_node_name(self) -> str:
        """
        The name of the virtual node that is acting as a service provider.
        """
        return pulumi.get(self, "virtual_node_name")


@pulumi.output_type
class GetVirtualServiceSpecProviderVirtualRouterResult(dict):
    def __init__(__self__, *,
                 virtual_router_name: str):
        """
        :param str virtual_router_name: The name of the virtual router that is acting as a service provider.
        """
        pulumi.set(__self__, "virtual_router_name", virtual_router_name)

    @property
    @pulumi.getter(name="virtualRouterName")
    def virtual_router_name(self) -> str:
        """
        The name of the virtual router that is acting as a service provider.
        """
        return pulumi.get(self, "virtual_router_name")


