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

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

__all__ = [
    'GatewayRouteSpec',
    'GatewayRouteSpecGrpcRoute',
    'GatewayRouteSpecGrpcRouteAction',
    'GatewayRouteSpecGrpcRouteActionTarget',
    'GatewayRouteSpecGrpcRouteActionTargetVirtualService',
    'GatewayRouteSpecGrpcRouteMatch',
    'GatewayRouteSpecHttp2Route',
    'GatewayRouteSpecHttp2RouteAction',
    'GatewayRouteSpecHttp2RouteActionRewrite',
    'GatewayRouteSpecHttp2RouteActionRewriteHostname',
    'GatewayRouteSpecHttp2RouteActionRewritePrefix',
    'GatewayRouteSpecHttp2RouteActionTarget',
    'GatewayRouteSpecHttp2RouteActionTargetVirtualService',
    'GatewayRouteSpecHttp2RouteMatch',
    'GatewayRouteSpecHttp2RouteMatchHostname',
    'GatewayRouteSpecHttpRoute',
    'GatewayRouteSpecHttpRouteAction',
    'GatewayRouteSpecHttpRouteActionRewrite',
    'GatewayRouteSpecHttpRouteActionRewriteHostname',
    'GatewayRouteSpecHttpRouteActionRewritePrefix',
    'GatewayRouteSpecHttpRouteActionTarget',
    'GatewayRouteSpecHttpRouteActionTargetVirtualService',
    'GatewayRouteSpecHttpRouteMatch',
    'GatewayRouteSpecHttpRouteMatchHostname',
    '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',
    'RouteSpecTcpRouteMatch',
    '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',
    'VirtualGatewaySpecLoggingAccessLogFileFormat',
    'VirtualGatewaySpecLoggingAccessLogFileFormatJson',
    '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',
    'VirtualNodeSpecLoggingAccessLogFileFormat',
    'VirtualNodeSpecLoggingAccessLogFileFormatJson',
    'VirtualNodeSpecServiceDiscovery',
    'VirtualNodeSpecServiceDiscoveryAwsCloudMap',
    'VirtualNodeSpecServiceDiscoveryDns',
    'VirtualRouterSpec',
    'VirtualRouterSpecListener',
    'VirtualRouterSpecListenerPortMapping',
    'VirtualServiceSpec',
    'VirtualServiceSpecProvider',
    'VirtualServiceSpecProviderVirtualNode',
    'VirtualServiceSpecProviderVirtualRouter',
    'GetMeshSpecResult',
    'GetMeshSpecEgressFilterResult',
    'GetRouteSpecResult',
    'GetRouteSpecGrpcRouteResult',
    'GetRouteSpecGrpcRouteActionResult',
    'GetRouteSpecGrpcRouteActionWeightedTargetResult',
    'GetRouteSpecGrpcRouteMatchResult',
    'GetRouteSpecGrpcRouteMatchMetadataResult',
    'GetRouteSpecGrpcRouteMatchMetadataMatchResult',
    'GetRouteSpecGrpcRouteMatchMetadataMatchRangeResult',
    'GetRouteSpecGrpcRouteRetryPolicyResult',
    'GetRouteSpecGrpcRouteRetryPolicyPerRetryTimeoutResult',
    'GetRouteSpecGrpcRouteTimeoutResult',
    'GetRouteSpecGrpcRouteTimeoutIdleResult',
    'GetRouteSpecGrpcRouteTimeoutPerRequestResult',
    'GetRouteSpecHttp2RouteResult',
    'GetRouteSpecHttp2RouteActionResult',
    'GetRouteSpecHttp2RouteActionWeightedTargetResult',
    'GetRouteSpecHttp2RouteMatchResult',
    'GetRouteSpecHttp2RouteMatchHeaderResult',
    'GetRouteSpecHttp2RouteMatchHeaderMatchResult',
    'GetRouteSpecHttp2RouteMatchHeaderMatchRangeResult',
    'GetRouteSpecHttp2RouteRetryPolicyResult',
    'GetRouteSpecHttp2RouteRetryPolicyPerRetryTimeoutResult',
    'GetRouteSpecHttp2RouteTimeoutResult',
    'GetRouteSpecHttp2RouteTimeoutIdleResult',
    'GetRouteSpecHttp2RouteTimeoutPerRequestResult',
    'GetRouteSpecHttpRouteResult',
    'GetRouteSpecHttpRouteActionResult',
    'GetRouteSpecHttpRouteActionWeightedTargetResult',
    'GetRouteSpecHttpRouteMatchResult',
    'GetRouteSpecHttpRouteMatchHeaderResult',
    'GetRouteSpecHttpRouteMatchHeaderMatchResult',
    'GetRouteSpecHttpRouteMatchHeaderMatchRangeResult',
    'GetRouteSpecHttpRouteRetryPolicyResult',
    'GetRouteSpecHttpRouteRetryPolicyPerRetryTimeoutResult',
    'GetRouteSpecHttpRouteTimeoutResult',
    'GetRouteSpecHttpRouteTimeoutIdleResult',
    'GetRouteSpecHttpRouteTimeoutPerRequestResult',
    'GetRouteSpecTcpRouteResult',
    'GetRouteSpecTcpRouteActionResult',
    'GetRouteSpecTcpRouteActionWeightedTargetResult',
    'GetRouteSpecTcpRouteMatchResult',
    'GetRouteSpecTcpRouteTimeoutResult',
    'GetRouteSpecTcpRouteTimeoutIdleResult',
    'GetVirtualGatewaySpecResult',
    'GetVirtualGatewaySpecBackendDefaultResult',
    'GetVirtualGatewaySpecBackendDefaultClientPolicyResult',
    'GetVirtualGatewaySpecBackendDefaultClientPolicyTlResult',
    'GetVirtualGatewaySpecBackendDefaultClientPolicyTlCertificateResult',
    'GetVirtualGatewaySpecBackendDefaultClientPolicyTlCertificateFileResult',
    'GetVirtualGatewaySpecBackendDefaultClientPolicyTlCertificateSdResult',
    'GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationResult',
    'GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationSubjectAlternativeNameResult',
    'GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationSubjectAlternativeNameMatchResult',
    'GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationTrustResult',
    'GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationTrustAcmResult',
    'GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationTrustFileResult',
    'GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationTrustSdResult',
    'GetVirtualGatewaySpecListenerResult',
    'GetVirtualGatewaySpecListenerConnectionPoolResult',
    'GetVirtualGatewaySpecListenerConnectionPoolGrpcResult',
    'GetVirtualGatewaySpecListenerConnectionPoolHttp2Result',
    'GetVirtualGatewaySpecListenerConnectionPoolHttpResult',
    'GetVirtualGatewaySpecListenerHealthCheckResult',
    'GetVirtualGatewaySpecListenerPortMappingResult',
    'GetVirtualGatewaySpecListenerTlResult',
    'GetVirtualGatewaySpecListenerTlCertificateResult',
    'GetVirtualGatewaySpecListenerTlCertificateAcmResult',
    'GetVirtualGatewaySpecListenerTlCertificateFileResult',
    'GetVirtualGatewaySpecListenerTlCertificateSdResult',
    'GetVirtualGatewaySpecListenerTlValidationResult',
    'GetVirtualGatewaySpecListenerTlValidationSubjectAlternativeNameResult',
    'GetVirtualGatewaySpecListenerTlValidationSubjectAlternativeNameMatchResult',
    'GetVirtualGatewaySpecListenerTlValidationTrustResult',
    'GetVirtualGatewaySpecListenerTlValidationTrustFileResult',
    'GetVirtualGatewaySpecListenerTlValidationTrustSdResult',
    'GetVirtualGatewaySpecLoggingResult',
    'GetVirtualGatewaySpecLoggingAccessLogResult',
    'GetVirtualGatewaySpecLoggingAccessLogFileResult',
    'GetVirtualGatewaySpecLoggingAccessLogFileFormatResult',
    'GetVirtualGatewaySpecLoggingAccessLogFileFormatJsonResult',
    '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: Specification of a gRPC gateway route.
        :param 'GatewayRouteSpecHttp2RouteArgs' http2_route: Specification of an HTTP/2 gateway route.
        :param 'GatewayRouteSpecHttpRouteArgs' http_route: 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']:
        """
        Specification of a gRPC gateway route.
        """
        return pulumi.get(self, "grpc_route")

    @property
    @pulumi.getter(name="http2Route")
    def http2_route(self) -> Optional['outputs.GatewayRouteSpecHttp2Route']:
        """
        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']:
        """
        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: Action to take if a match is determined.
        :param 'GatewayRouteSpecGrpcRouteMatchArgs' match: Criteria for determining a request match.
        """
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "match", match)

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

    @property
    @pulumi.getter
    def match(self) -> 'outputs.GatewayRouteSpecGrpcRouteMatch':
        """
        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: 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':
        """
        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: Virtual service gateway route target.
        """
        pulumi.set(__self__, "virtual_service", virtual_service)

    @property
    @pulumi.getter(name="virtualService")
    def virtual_service(self) -> 'outputs.GatewayRouteSpecGrpcRouteActionTargetVirtualService':
        """
        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: 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:
        """
        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,
                 port: Optional[int] = None):
        """
        :param str service_name: Fully qualified domain name for the service to match from the request.
        :param int port: The port number to match from the request.
        """
        pulumi.set(__self__, "service_name", service_name)
        if port is not None:
            pulumi.set(__self__, "port", port)

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

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        The port number to match from the request.
        """
        return pulumi.get(self, "port")


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

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

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


@pulumi.output_type
class GatewayRouteSpecHttp2RouteAction(dict):
    def __init__(__self__, *,
                 target: 'outputs.GatewayRouteSpecHttp2RouteActionTarget',
                 rewrite: Optional['outputs.GatewayRouteSpecHttp2RouteActionRewrite'] = None):
        """
        :param 'GatewayRouteSpecHttp2RouteActionTargetArgs' target: Target that traffic is routed to when a request matches the gateway route.
        :param 'GatewayRouteSpecHttp2RouteActionRewriteArgs' rewrite: Gateway route action to rewrite.
        """
        pulumi.set(__self__, "target", target)
        if rewrite is not None:
            pulumi.set(__self__, "rewrite", rewrite)

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

    @property
    @pulumi.getter
    def rewrite(self) -> Optional['outputs.GatewayRouteSpecHttp2RouteActionRewrite']:
        """
        Gateway route action to rewrite.
        """
        return pulumi.get(self, "rewrite")


@pulumi.output_type
class GatewayRouteSpecHttp2RouteActionRewrite(dict):
    def __init__(__self__, *,
                 hostname: Optional['outputs.GatewayRouteSpecHttp2RouteActionRewriteHostname'] = None,
                 prefix: Optional['outputs.GatewayRouteSpecHttp2RouteActionRewritePrefix'] = None):
        """
        :param 'GatewayRouteSpecHttp2RouteActionRewriteHostnameArgs' hostname: Host name to rewrite.
        :param 'GatewayRouteSpecHttp2RouteActionRewritePrefixArgs' prefix: Specified beginning characters to rewrite.
        """
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)

    @property
    @pulumi.getter
    def hostname(self) -> Optional['outputs.GatewayRouteSpecHttp2RouteActionRewriteHostname']:
        """
        Host name to rewrite.
        """
        return pulumi.get(self, "hostname")

    @property
    @pulumi.getter
    def prefix(self) -> Optional['outputs.GatewayRouteSpecHttp2RouteActionRewritePrefix']:
        """
        Specified beginning characters to rewrite.
        """
        return pulumi.get(self, "prefix")


@pulumi.output_type
class GatewayRouteSpecHttp2RouteActionRewriteHostname(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultTargetHostname":
            suggest = "default_target_hostname"

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

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

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

    def __init__(__self__, *,
                 default_target_hostname: str):
        """
        :param str default_target_hostname: Default target host name to write to. Valid values: `ENABLED`, `DISABLED`.
        """
        pulumi.set(__self__, "default_target_hostname", default_target_hostname)

    @property
    @pulumi.getter(name="defaultTargetHostname")
    def default_target_hostname(self) -> str:
        """
        Default target host name to write to. Valid values: `ENABLED`, `DISABLED`.
        """
        return pulumi.get(self, "default_target_hostname")


@pulumi.output_type
class GatewayRouteSpecHttp2RouteActionRewritePrefix(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultPrefix":
            suggest = "default_prefix"

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

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

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

    def __init__(__self__, *,
                 default_prefix: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str default_prefix: Default prefix used to replace the incoming route prefix when rewritten. Valid values: `ENABLED`, `DISABLED`.
        :param str value: Value used to replace the incoming route prefix when rewritten.
        """
        if default_prefix is not None:
            pulumi.set(__self__, "default_prefix", default_prefix)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="defaultPrefix")
    def default_prefix(self) -> Optional[str]:
        """
        Default prefix used to replace the incoming route prefix when rewritten. Valid values: `ENABLED`, `DISABLED`.
        """
        return pulumi.get(self, "default_prefix")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        Value used to replace the incoming route prefix when rewritten.
        """
        return pulumi.get(self, "value")


@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: Virtual service gateway route target.
        """
        pulumi.set(__self__, "virtual_service", virtual_service)

    @property
    @pulumi.getter(name="virtualService")
    def virtual_service(self) -> 'outputs.GatewayRouteSpecHttp2RouteActionTargetVirtualService':
        """
        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: 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:
        """
        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__, *,
                 hostname: Optional['outputs.GatewayRouteSpecHttp2RouteMatchHostname'] = None,
                 port: Optional[int] = None,
                 prefix: Optional[str] = None):
        """
        :param 'GatewayRouteSpecHttp2RouteMatchHostnameArgs' hostname: Host name to rewrite.
        :param int port: The port number to match from the request.
        :param str prefix: Specified beginning characters to rewrite.
        """
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)

    @property
    @pulumi.getter
    def hostname(self) -> Optional['outputs.GatewayRouteSpecHttp2RouteMatchHostname']:
        """
        Host name to rewrite.
        """
        return pulumi.get(self, "hostname")

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        The port number to match from the request.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def prefix(self) -> Optional[str]:
        """
        Specified beginning characters to rewrite.
        """
        return pulumi.get(self, "prefix")


@pulumi.output_type
class GatewayRouteSpecHttp2RouteMatchHostname(dict):
    def __init__(__self__, *,
                 exact: Optional[str] = None,
                 suffix: Optional[str] = None):
        """
        :param str exact: Exact host name to match on.
        :param str suffix: Specified ending characters of the host name to match on.
        """
        if exact is not None:
            pulumi.set(__self__, "exact", exact)
        if suffix is not None:
            pulumi.set(__self__, "suffix", suffix)

    @property
    @pulumi.getter
    def exact(self) -> Optional[str]:
        """
        Exact host name to match on.
        """
        return pulumi.get(self, "exact")

    @property
    @pulumi.getter
    def suffix(self) -> Optional[str]:
        """
        Specified ending characters of the host name to match on.
        """
        return pulumi.get(self, "suffix")


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

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

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


@pulumi.output_type
class GatewayRouteSpecHttpRouteAction(dict):
    def __init__(__self__, *,
                 target: 'outputs.GatewayRouteSpecHttpRouteActionTarget',
                 rewrite: Optional['outputs.GatewayRouteSpecHttpRouteActionRewrite'] = None):
        """
        :param 'GatewayRouteSpecHttpRouteActionTargetArgs' target: Target that traffic is routed to when a request matches the gateway route.
        :param 'GatewayRouteSpecHttpRouteActionRewriteArgs' rewrite: Gateway route action to rewrite.
        """
        pulumi.set(__self__, "target", target)
        if rewrite is not None:
            pulumi.set(__self__, "rewrite", rewrite)

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

    @property
    @pulumi.getter
    def rewrite(self) -> Optional['outputs.GatewayRouteSpecHttpRouteActionRewrite']:
        """
        Gateway route action to rewrite.
        """
        return pulumi.get(self, "rewrite")


@pulumi.output_type
class GatewayRouteSpecHttpRouteActionRewrite(dict):
    def __init__(__self__, *,
                 hostname: Optional['outputs.GatewayRouteSpecHttpRouteActionRewriteHostname'] = None,
                 prefix: Optional['outputs.GatewayRouteSpecHttpRouteActionRewritePrefix'] = None):
        """
        :param 'GatewayRouteSpecHttpRouteActionRewriteHostnameArgs' hostname: Host name to rewrite.
        :param 'GatewayRouteSpecHttpRouteActionRewritePrefixArgs' prefix: Specified beginning characters to rewrite.
        """
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)

    @property
    @pulumi.getter
    def hostname(self) -> Optional['outputs.GatewayRouteSpecHttpRouteActionRewriteHostname']:
        """
        Host name to rewrite.
        """
        return pulumi.get(self, "hostname")

    @property
    @pulumi.getter
    def prefix(self) -> Optional['outputs.GatewayRouteSpecHttpRouteActionRewritePrefix']:
        """
        Specified beginning characters to rewrite.
        """
        return pulumi.get(self, "prefix")


@pulumi.output_type
class GatewayRouteSpecHttpRouteActionRewriteHostname(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultTargetHostname":
            suggest = "default_target_hostname"

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

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

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

    def __init__(__self__, *,
                 default_target_hostname: str):
        """
        :param str default_target_hostname: Default target host name to write to. Valid values: `ENABLED`, `DISABLED`.
        """
        pulumi.set(__self__, "default_target_hostname", default_target_hostname)

    @property
    @pulumi.getter(name="defaultTargetHostname")
    def default_target_hostname(self) -> str:
        """
        Default target host name to write to. Valid values: `ENABLED`, `DISABLED`.
        """
        return pulumi.get(self, "default_target_hostname")


@pulumi.output_type
class GatewayRouteSpecHttpRouteActionRewritePrefix(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultPrefix":
            suggest = "default_prefix"

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

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

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

    def __init__(__self__, *,
                 default_prefix: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str default_prefix: Default prefix used to replace the incoming route prefix when rewritten. Valid values: `ENABLED`, `DISABLED`.
        :param str value: Value used to replace the incoming route prefix when rewritten.
        """
        if default_prefix is not None:
            pulumi.set(__self__, "default_prefix", default_prefix)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="defaultPrefix")
    def default_prefix(self) -> Optional[str]:
        """
        Default prefix used to replace the incoming route prefix when rewritten. Valid values: `ENABLED`, `DISABLED`.
        """
        return pulumi.get(self, "default_prefix")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        Value used to replace the incoming route prefix when rewritten.
        """
        return pulumi.get(self, "value")


@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: Virtual service gateway route target.
        """
        pulumi.set(__self__, "virtual_service", virtual_service)

    @property
    @pulumi.getter(name="virtualService")
    def virtual_service(self) -> 'outputs.GatewayRouteSpecHttpRouteActionTargetVirtualService':
        """
        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: 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:
        """
        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__, *,
                 hostname: Optional['outputs.GatewayRouteSpecHttpRouteMatchHostname'] = None,
                 port: Optional[int] = None,
                 prefix: Optional[str] = None):
        """
        :param 'GatewayRouteSpecHttpRouteMatchHostnameArgs' hostname: Host name to rewrite.
        :param int port: The port number to match from the request.
        :param str prefix: Specified beginning characters to rewrite.
        """
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)

    @property
    @pulumi.getter
    def hostname(self) -> Optional['outputs.GatewayRouteSpecHttpRouteMatchHostname']:
        """
        Host name to rewrite.
        """
        return pulumi.get(self, "hostname")

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        The port number to match from the request.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def prefix(self) -> Optional[str]:
        """
        Specified beginning characters to rewrite.
        """
        return pulumi.get(self, "prefix")


@pulumi.output_type
class GatewayRouteSpecHttpRouteMatchHostname(dict):
    def __init__(__self__, *,
                 exact: Optional[str] = None,
                 suffix: Optional[str] = None):
        """
        :param str exact: Exact host name to match on.
        :param str suffix: Specified ending characters of the host name to match on.
        """
        if exact is not None:
            pulumi.set(__self__, "exact", exact)
        if suffix is not None:
            pulumi.set(__self__, "suffix", suffix)

    @property
    @pulumi.getter
    def exact(self) -> Optional[str]:
        """
        Exact host name to match on.
        """
        return pulumi.get(self, "exact")

    @property
    @pulumi.getter
    def suffix(self) -> Optional[str]:
        """
        Specified ending characters of the host name to match on.
        """
        return pulumi.get(self, "suffix")


@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: 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']:
        """
        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: 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]:
        """
        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: GRPC routing information for the route.
        :param 'RouteSpecHttp2RouteArgs' http2_route: HTTP/2 routing information for the route.
        :param 'RouteSpecHttpRouteArgs' http_route: HTTP routing information for the route.
        :param int priority: 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: 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']:
        """
        GRPC routing information for the route.
        """
        return pulumi.get(self, "grpc_route")

    @property
    @pulumi.getter(name="http2Route")
    def http2_route(self) -> Optional['outputs.RouteSpecHttp2Route']:
        """
        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']:
        """
        HTTP routing information for the route.
        """
        return pulumi.get(self, "http_route")

    @property
    @pulumi.getter
    def priority(self) -> Optional[int]:
        """
        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']:
        """
        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: Action to take if a match is determined.
        :param 'RouteSpecGrpcRouteMatchArgs' match: Criteria for determining an gRPC request match.
        :param 'RouteSpecGrpcRouteRetryPolicyArgs' retry_policy: Retry policy.
        :param 'RouteSpecGrpcRouteTimeoutArgs' timeout: 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':
        """
        Action to take if a match is determined.
        """
        return pulumi.get(self, "action")

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

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

    @property
    @pulumi.getter
    def timeout(self) -> Optional['outputs.RouteSpecGrpcRouteTimeout']:
        """
        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: 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']:
        """
        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,
                 port: Optional[int] = None):
        """
        :param str virtual_node: Virtual node to associate with the weighted target. Must be between 1 and 255 characters in length.
        :param int weight: Relative weight of the weighted target. An integer between 0 and 100.
        :param int port: The targeted port of the weighted object.
        """
        pulumi.set(__self__, "virtual_node", virtual_node)
        pulumi.set(__self__, "weight", weight)
        if port is not None:
            pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter(name="virtualNode")
    def virtual_node(self) -> str:
        """
        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:
        """
        Relative weight of the weighted target. An integer between 0 and 100.
        """
        return pulumi.get(self, "weight")

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        The targeted port of the weighted object.
        """
        return pulumi.get(self, "port")


@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,
                 port: Optional[int] = None,
                 prefix: Optional[str] = None,
                 service_name: Optional[str] = None):
        """
        :param Sequence['RouteSpecGrpcRouteMatchMetadataArgs'] metadatas: Data to match from the gRPC request.
        :param str method_name: Method name to match from the request. If you specify a name, you must also specify a `service_name`.
        :param int port: The port number to match from the request.
        :param str prefix: 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: 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 port is not None:
            pulumi.set(__self__, "port", port)
        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']]:
        """
        Data to match from the gRPC request.
        """
        return pulumi.get(self, "metadatas")

    @property
    @pulumi.getter(name="methodName")
    def method_name(self) -> Optional[str]:
        """
        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 port(self) -> Optional[int]:
        """
        The port number to match from the request.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def prefix(self) -> Optional[str]:
        """
        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]:
        """
        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: 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: 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:
        """
        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']:
        """
        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: Value sent by the client must match the specified value exactly. Must be between 1 and 255 characters in length.
        :param str prefix: 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: Object that specifies the range of numbers that the value sent by the client must be included in.
        :param str regex: Value sent by the client must include the specified characters. Must be between 1 and 255 characters in length.
        :param str suffix: 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]:
        """
        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]:
        """
        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']:
        """
        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]:
        """
        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]:
        """
        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: End of the range.
        :param int start: Start of the range.
        """
        pulumi.set(__self__, "end", end)
        pulumi.set(__self__, "start", start)

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

    @property
    @pulumi.getter
    def start(self) -> int:
        """
        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: Maximum number of retries.
        :param 'RouteSpecGrpcRouteRetryPolicyPerRetryTimeoutArgs' per_retry_timeout: 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:
        """
        Maximum number of retries.
        """
        return pulumi.get(self, "max_retries")

    @property
    @pulumi.getter(name="perRetryTimeout")
    def per_retry_timeout(self) -> 'outputs.RouteSpecGrpcRouteRetryPolicyPerRetryTimeout':
        """
        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: Idle timeout. An idle timeout bounds the amount of time that a connection may be idle.
        :param 'RouteSpecGrpcRouteTimeoutPerRequestArgs' per_request: 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']:
        """
        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']:
        """
        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: Unit of time. Valid values: `ms`, `s`.
        :param int value: 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:
        """
        Unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        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: Unit of time. Valid values: `ms`, `s`.
        :param int value: 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:
        """
        Unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        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: Action to take if a match is determined.
        :param 'RouteSpecHttp2RouteMatchArgs' match: Criteria for determining an gRPC request match.
        :param 'RouteSpecHttp2RouteRetryPolicyArgs' retry_policy: Retry policy.
        :param 'RouteSpecHttp2RouteTimeoutArgs' timeout: 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':
        """
        Action to take if a match is determined.
        """
        return pulumi.get(self, "action")

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

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

    @property
    @pulumi.getter
    def timeout(self) -> Optional['outputs.RouteSpecHttp2RouteTimeout']:
        """
        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: 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']:
        """
        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,
                 port: Optional[int] = None):
        """
        :param str virtual_node: Virtual node to associate with the weighted target. Must be between 1 and 255 characters in length.
        :param int weight: Relative weight of the weighted target. An integer between 0 and 100.
        :param int port: The targeted port of the weighted object.
        """
        pulumi.set(__self__, "virtual_node", virtual_node)
        pulumi.set(__self__, "weight", weight)
        if port is not None:
            pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter(name="virtualNode")
    def virtual_node(self) -> str:
        """
        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:
        """
        Relative weight of the weighted target. An integer between 0 and 100.
        """
        return pulumi.get(self, "weight")

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        The targeted port of the weighted object.
        """
        return pulumi.get(self, "port")


@pulumi.output_type
class RouteSpecHttp2RouteMatch(dict):
    def __init__(__self__, *,
                 prefix: str,
                 headers: Optional[Sequence['outputs.RouteSpecHttp2RouteMatchHeader']] = None,
                 method: Optional[str] = None,
                 port: Optional[int] = None,
                 scheme: Optional[str] = None):
        """
        :param str prefix: 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: Client request headers to match on.
        :param str method: Client request header method to match on. Valid values: `GET`, `HEAD`, `POST`, `PUT`, `DELETE`, `CONNECT`, `OPTIONS`, `TRACE`, `PATCH`.
        :param int port: The port number to match from the request.
        :param str scheme: 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 port is not None:
            pulumi.set(__self__, "port", port)
        if scheme is not None:
            pulumi.set(__self__, "scheme", scheme)

    @property
    @pulumi.getter
    def prefix(self) -> str:
        """
        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']]:
        """
        Client request headers to match on.
        """
        return pulumi.get(self, "headers")

    @property
    @pulumi.getter
    def method(self) -> Optional[str]:
        """
        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 port(self) -> Optional[int]:
        """
        The port number to match from the request.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def scheme(self) -> Optional[str]:
        """
        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: 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: 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:
        """
        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']:
        """
        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: Value sent by the client must match the specified value exactly. Must be between 1 and 255 characters in length.
        :param str prefix: 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: Object that specifies the range of numbers that the value sent by the client must be included in.
        :param str regex: Value sent by the client must include the specified characters. Must be between 1 and 255 characters in length.
        :param str suffix: 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]:
        """
        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]:
        """
        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']:
        """
        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]:
        """
        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]:
        """
        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: End of the range.
        :param int start: Start of the range.
        """
        pulumi.set(__self__, "end", end)
        pulumi.set(__self__, "start", start)

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

    @property
    @pulumi.getter
    def start(self) -> int:
        """
        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: Maximum number of retries.
        :param 'RouteSpecHttp2RouteRetryPolicyPerRetryTimeoutArgs' per_retry_timeout: 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:
        """
        Maximum number of retries.
        """
        return pulumi.get(self, "max_retries")

    @property
    @pulumi.getter(name="perRetryTimeout")
    def per_retry_timeout(self) -> 'outputs.RouteSpecHttp2RouteRetryPolicyPerRetryTimeout':
        """
        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: Idle timeout. An idle timeout bounds the amount of time that a connection may be idle.
        :param 'RouteSpecHttp2RouteTimeoutPerRequestArgs' per_request: 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']:
        """
        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']:
        """
        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: Unit of time. Valid values: `ms`, `s`.
        :param int value: 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:
        """
        Unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        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: Unit of time. Valid values: `ms`, `s`.
        :param int value: 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:
        """
        Unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        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: Action to take if a match is determined.
        :param 'RouteSpecHttpRouteMatchArgs' match: Criteria for determining an HTTP request match.
        :param 'RouteSpecHttpRouteRetryPolicyArgs' retry_policy: Retry policy.
        :param 'RouteSpecHttpRouteTimeoutArgs' timeout: 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':
        """
        Action to take if a match is determined.
        """
        return pulumi.get(self, "action")

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

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

    @property
    @pulumi.getter
    def timeout(self) -> Optional['outputs.RouteSpecHttpRouteTimeout']:
        """
        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: 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']:
        """
        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,
                 port: Optional[int] = None):
        """
        :param str virtual_node: Virtual node to associate with the weighted target. Must be between 1 and 255 characters in length.
        :param int weight: Relative weight of the weighted target. An integer between 0 and 100.
        :param int port: The targeted port of the weighted object.
        """
        pulumi.set(__self__, "virtual_node", virtual_node)
        pulumi.set(__self__, "weight", weight)
        if port is not None:
            pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter(name="virtualNode")
    def virtual_node(self) -> str:
        """
        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:
        """
        Relative weight of the weighted target. An integer between 0 and 100.
        """
        return pulumi.get(self, "weight")

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        The targeted port of the weighted object.
        """
        return pulumi.get(self, "port")


@pulumi.output_type
class RouteSpecHttpRouteMatch(dict):
    def __init__(__self__, *,
                 prefix: str,
                 headers: Optional[Sequence['outputs.RouteSpecHttpRouteMatchHeader']] = None,
                 method: Optional[str] = None,
                 port: Optional[int] = None,
                 scheme: Optional[str] = None):
        """
        :param str prefix: 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: Client request headers to match on.
        :param str method: Client request header method to match on. Valid values: `GET`, `HEAD`, `POST`, `PUT`, `DELETE`, `CONNECT`, `OPTIONS`, `TRACE`, `PATCH`.
        :param int port: The port number to match from the request.
        :param str scheme: 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 port is not None:
            pulumi.set(__self__, "port", port)
        if scheme is not None:
            pulumi.set(__self__, "scheme", scheme)

    @property
    @pulumi.getter
    def prefix(self) -> str:
        """
        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']]:
        """
        Client request headers to match on.
        """
        return pulumi.get(self, "headers")

    @property
    @pulumi.getter
    def method(self) -> Optional[str]:
        """
        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 port(self) -> Optional[int]:
        """
        The port number to match from the request.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def scheme(self) -> Optional[str]:
        """
        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: 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: 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:
        """
        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']:
        """
        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: Value sent by the client must match the specified value exactly. Must be between 1 and 255 characters in length.
        :param str prefix: 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: Object that specifies the range of numbers that the value sent by the client must be included in.
        :param str regex: Value sent by the client must include the specified characters. Must be between 1 and 255 characters in length.
        :param str suffix: 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]:
        """
        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]:
        """
        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']:
        """
        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]:
        """
        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]:
        """
        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: End of the range.
        :param int start: Start of the range.
        """
        pulumi.set(__self__, "end", end)
        pulumi.set(__self__, "start", start)

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

    @property
    @pulumi.getter
    def start(self) -> int:
        """
        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: Maximum number of retries.
        :param 'RouteSpecHttpRouteRetryPolicyPerRetryTimeoutArgs' per_retry_timeout: 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:
        """
        Maximum number of retries.
        """
        return pulumi.get(self, "max_retries")

    @property
    @pulumi.getter(name="perRetryTimeout")
    def per_retry_timeout(self) -> 'outputs.RouteSpecHttpRouteRetryPolicyPerRetryTimeout':
        """
        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: Idle timeout. An idle timeout bounds the amount of time that a connection may be idle.
        :param 'RouteSpecHttpRouteTimeoutPerRequestArgs' per_request: 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']:
        """
        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']:
        """
        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: Unit of time. Valid values: `ms`, `s`.
        :param int value: 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:
        """
        Unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        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: Unit of time. Valid values: `ms`, `s`.
        :param int value: 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:
        """
        Unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        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',
                 match: Optional['outputs.RouteSpecTcpRouteMatch'] = None,
                 timeout: Optional['outputs.RouteSpecTcpRouteTimeout'] = None):
        """
        :param 'RouteSpecTcpRouteActionArgs' action: Action to take if a match is determined.
        :param 'RouteSpecTcpRouteMatchArgs' match: Criteria for determining an gRPC request match.
        :param 'RouteSpecTcpRouteTimeoutArgs' timeout: Types of timeouts.
        """
        pulumi.set(__self__, "action", action)
        if match is not None:
            pulumi.set(__self__, "match", match)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

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

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

    @property
    @pulumi.getter
    def timeout(self) -> Optional['outputs.RouteSpecTcpRouteTimeout']:
        """
        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: 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']:
        """
        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,
                 port: Optional[int] = None):
        """
        :param str virtual_node: Virtual node to associate with the weighted target. Must be between 1 and 255 characters in length.
        :param int weight: Relative weight of the weighted target. An integer between 0 and 100.
        :param int port: The targeted port of the weighted object.
        """
        pulumi.set(__self__, "virtual_node", virtual_node)
        pulumi.set(__self__, "weight", weight)
        if port is not None:
            pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter(name="virtualNode")
    def virtual_node(self) -> str:
        """
        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:
        """
        Relative weight of the weighted target. An integer between 0 and 100.
        """
        return pulumi.get(self, "weight")

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        The targeted port of the weighted object.
        """
        return pulumi.get(self, "port")


@pulumi.output_type
class RouteSpecTcpRouteMatch(dict):
    def __init__(__self__, *,
                 port: Optional[int] = None):
        """
        :param int port: The port number to match from the request.
        """
        if port is not None:
            pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        The port number to match from the request.
        """
        return pulumi.get(self, "port")


@pulumi.output_type
class RouteSpecTcpRouteTimeout(dict):
    def __init__(__self__, *,
                 idle: Optional['outputs.RouteSpecTcpRouteTimeoutIdle'] = None):
        """
        :param 'RouteSpecTcpRouteTimeoutIdleArgs' idle: 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']:
        """
        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: Unit of time. Valid values: `ms`, `s`.
        :param int value: 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:
        """
        Unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        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: Listeners that the mesh endpoint is expected to receive inbound traffic from. You can specify one listener.
        :param 'VirtualGatewaySpecBackendDefaultsArgs' backend_defaults: Defaults for backends.
        :param 'VirtualGatewaySpecLoggingArgs' logging: 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':
        """
        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']:
        """
        Defaults for backends.
        """
        return pulumi.get(self, "backend_defaults")

    @property
    @pulumi.getter
    def logging(self) -> Optional['outputs.VirtualGatewaySpecLogging']:
        """
        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: 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']:
        """
        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: 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']:
        """
        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: Listener's Transport Layer Security (TLS) validation context.
        :param 'VirtualGatewaySpecBackendDefaultsClientPolicyTlsCertificateArgs' certificate: 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':
        """
        Listener's Transport Layer Security (TLS) validation context.
        """
        return pulumi.get(self, "validation")

    @property
    @pulumi.getter
    def certificate(self) -> Optional['outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsCertificate']:
        """
        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: 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']:
        """
        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: 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: 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:
        """
        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:
        """
        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: 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:
        """
        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: TLS validation context trust.
        :param 'VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesArgs' subject_alternative_names: 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':
        """
        TLS validation context trust.
        """
        return pulumi.get(self, "trust")

    @property
    @pulumi.getter(name="subjectAlternativeNames")
    def subject_alternative_names(self) -> Optional['outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNames']:
        """
        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: Criteria for determining a SAN's match.
        """
        pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def match(self) -> 'outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatch':
        """
        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: Values sent must match the specified values exactly.
        """
        pulumi.set(__self__, "exacts", exacts)

    @property
    @pulumi.getter
    def exacts(self) -> Sequence[str]:
        """
        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: TLS validation context trust for an AWS Certificate Manager (ACM) certificate.
        :param 'VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustFileArgs' file: TLS validation context trust for a local file certificate.
        :param 'VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustSdsArgs' sds: 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']:
        """
        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']:
        """
        TLS validation context trust for a local file certificate.
        """
        return pulumi.get(self, "file")

    @property
    @pulumi.getter
    def sds(self) -> Optional['outputs.VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustSds']:
        """
        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 ARNs.
        """
        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 ARNs.
        """
        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: 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:
        """
        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: 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:
        """
        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: Port mapping information for the listener.
        :param 'VirtualGatewaySpecListenerConnectionPoolArgs' connection_pool: Connection pool information for the listener.
        :param 'VirtualGatewaySpecListenerHealthCheckArgs' health_check: Health check information for the listener.
        :param 'VirtualGatewaySpecListenerTlsArgs' tls: 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':
        """
        Port mapping information for the listener.
        """
        return pulumi.get(self, "port_mapping")

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

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

    @property
    @pulumi.getter
    def tls(self) -> Optional['outputs.VirtualGatewaySpecListenerTls']:
        """
        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: Number of consecutive successful health checks that must occur before declaring listener healthy.
        :param int interval_millis: Time period in milliseconds between each health check execution.
        :param str protocol: Protocol for the health check request. Valid values are `http`, `http2`, and `grpc`.
        :param int timeout_millis: Amount of time to wait when receiving a response from the health check, in milliseconds.
        :param int unhealthy_threshold: Number of consecutive failed health checks that must occur before declaring a virtual gateway unhealthy.
        :param str path: Destination path for the health check request. This is only required if the specified protocol is `http` or `http2`.
        :param int port: 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:
        """
        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:
        """
        Time period in milliseconds between each health check execution.
        """
        return pulumi.get(self, "interval_millis")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        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:
        """
        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:
        """
        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]:
        """
        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]:
        """
        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: Port used for the port mapping.
        :param str protocol: 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:
        """
        Port used for the port mapping.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        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: Listener's TLS certificate.
        :param str mode: Listener's TLS mode. Valid values: `DISABLED`, `PERMISSIVE`, `STRICT`.
        :param 'VirtualGatewaySpecListenerTlsValidationArgs' validation: 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':
        """
        Listener's TLS certificate.
        """
        return pulumi.get(self, "certificate")

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

    @property
    @pulumi.getter
    def validation(self) -> Optional['outputs.VirtualGatewaySpecListenerTlsValidation']:
        """
        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: 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']:
        """
        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: ARN for the certificate.
        """
        pulumi.set(__self__, "certificate_arn", certificate_arn)

    @property
    @pulumi.getter(name="certificateArn")
    def certificate_arn(self) -> str:
        """
        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: 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: 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:
        """
        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:
        """
        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: 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:
        """
        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: TLS validation context trust.
        :param 'VirtualGatewaySpecListenerTlsValidationSubjectAlternativeNamesArgs' subject_alternative_names: 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':
        """
        TLS validation context trust.
        """
        return pulumi.get(self, "trust")

    @property
    @pulumi.getter(name="subjectAlternativeNames")
    def subject_alternative_names(self) -> Optional['outputs.VirtualGatewaySpecListenerTlsValidationSubjectAlternativeNames']:
        """
        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: Criteria for determining a SAN's match.
        """
        pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def match(self) -> 'outputs.VirtualGatewaySpecListenerTlsValidationSubjectAlternativeNamesMatch':
        """
        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: Values sent must match the specified values exactly.
        """
        pulumi.set(__self__, "exacts", exacts)

    @property
    @pulumi.getter
    def exacts(self) -> Sequence[str]:
        """
        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: TLS validation context trust for a local file certificate.
        :param 'VirtualGatewaySpecListenerTlsValidationTrustSdsArgs' sds: 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']:
        """
        TLS validation context trust for a local file certificate.
        """
        return pulumi.get(self, "file")

    @property
    @pulumi.getter
    def sds(self) -> Optional['outputs.VirtualGatewaySpecListenerTlsValidationTrustSds']:
        """
        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: 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:
        """
        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: 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:
        """
        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: 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']:
        """
        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: 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']:
        """
        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,
                 format: Optional['outputs.VirtualGatewaySpecLoggingAccessLogFileFormat'] = None):
        """
        :param str path: 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.
        :param 'VirtualGatewaySpecLoggingAccessLogFileFormatArgs' format: The specified format for the logs.
        """
        pulumi.set(__self__, "path", path)
        if format is not None:
            pulumi.set(__self__, "format", format)

    @property
    @pulumi.getter
    def path(self) -> str:
        """
        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")

    @property
    @pulumi.getter
    def format(self) -> Optional['outputs.VirtualGatewaySpecLoggingAccessLogFileFormat']:
        """
        The specified format for the logs.
        """
        return pulumi.get(self, "format")


@pulumi.output_type
class VirtualGatewaySpecLoggingAccessLogFileFormat(dict):
    def __init__(__self__, *,
                 jsons: Optional[Sequence['outputs.VirtualGatewaySpecLoggingAccessLogFileFormatJson']] = None,
                 text: Optional[str] = None):
        """
        :param Sequence['VirtualGatewaySpecLoggingAccessLogFileFormatJsonArgs'] jsons: The logging format for JSON.
        :param str text: The logging format for text. Must be between 1 and 1000 characters in length.
        """
        if jsons is not None:
            pulumi.set(__self__, "jsons", jsons)
        if text is not None:
            pulumi.set(__self__, "text", text)

    @property
    @pulumi.getter
    def jsons(self) -> Optional[Sequence['outputs.VirtualGatewaySpecLoggingAccessLogFileFormatJson']]:
        """
        The logging format for JSON.
        """
        return pulumi.get(self, "jsons")

    @property
    @pulumi.getter
    def text(self) -> Optional[str]:
        """
        The logging format for text. Must be between 1 and 1000 characters in length.
        """
        return pulumi.get(self, "text")


@pulumi.output_type
class VirtualGatewaySpecLoggingAccessLogFileFormatJson(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        """
        :param str key: The specified key for the JSON. Must be between 1 and 100 characters in length.
        :param str value: The specified value for the JSON. Must be between 1 and 100 characters in length.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The specified key for the JSON. Must be between 1 and 100 characters in length.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The specified value for the JSON. Must be between 1 and 100 characters in length.
        """
        return pulumi.get(self, "value")


@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: Defaults for backends.
        :param Sequence['VirtualNodeSpecBackendArgs'] backends: Backends to which the virtual node is expected to send outbound traffic.
        :param 'VirtualNodeSpecListenerArgs' listener: Listeners from which the virtual node is expected to receive inbound traffic.
        :param 'VirtualNodeSpecLoggingArgs' logging: Inbound and outbound access logging information for the virtual node.
        :param 'VirtualNodeSpecServiceDiscoveryArgs' service_discovery: 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']:
        """
        Defaults for backends.
        """
        return pulumi.get(self, "backend_defaults")

    @property
    @pulumi.getter
    def backends(self) -> Optional[Sequence['outputs.VirtualNodeSpecBackend']]:
        """
        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']:
        """
        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']:
        """
        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']:
        """
        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: 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':
        """
        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: 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']:
        """
        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: 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']:
        """
        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: Listener's Transport Layer Security (TLS) validation context.
        :param 'VirtualNodeSpecBackendDefaultsClientPolicyTlsCertificateArgs' certificate: 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':
        """
        Listener's Transport Layer Security (TLS) validation context.
        """
        return pulumi.get(self, "validation")

    @property
    @pulumi.getter
    def certificate(self) -> Optional['outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsCertificate']:
        """
        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: 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']:
        """
        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: 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: 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:
        """
        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:
        """
        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: 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:
        """
        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: TLS validation context trust.
        :param 'VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesArgs' subject_alternative_names: 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':
        """
        TLS validation context trust.
        """
        return pulumi.get(self, "trust")

    @property
    @pulumi.getter(name="subjectAlternativeNames")
    def subject_alternative_names(self) -> Optional['outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNames']:
        """
        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: Criteria for determining a SAN's match.
        """
        pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def match(self) -> 'outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatch':
        """
        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: Values sent must match the specified values exactly.
        """
        pulumi.set(__self__, "exacts", exacts)

    @property
    @pulumi.getter
    def exacts(self) -> Sequence[str]:
        """
        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: TLS validation context trust for an AWS Certificate Manager (ACM) certificate.
        :param 'VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustFileArgs' file: TLS validation context trust for a local file certificate.
        :param 'VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustSdsArgs' sds: 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']:
        """
        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']:
        """
        TLS validation context trust for a local file certificate.
        """
        return pulumi.get(self, "file")

    @property
    @pulumi.getter
    def sds(self) -> Optional['outputs.VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustSds']:
        """
        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 ARNs.
        """
        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 ARNs.
        """
        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: 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:
        """
        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: 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:
        """
        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: 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: 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:
        """
        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']:
        """
        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: 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']:
        """
        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: Listener's Transport Layer Security (TLS) validation context.
        :param 'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsCertificateArgs' certificate: 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':
        """
        Listener's Transport Layer Security (TLS) validation context.
        """
        return pulumi.get(self, "validation")

    @property
    @pulumi.getter
    def certificate(self) -> Optional['outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsCertificate']:
        """
        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: 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']:
        """
        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: 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: 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:
        """
        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:
        """
        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: 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:
        """
        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: TLS validation context trust.
        :param 'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesArgs' subject_alternative_names: 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':
        """
        TLS validation context trust.
        """
        return pulumi.get(self, "trust")

    @property
    @pulumi.getter(name="subjectAlternativeNames")
    def subject_alternative_names(self) -> Optional['outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationSubjectAlternativeNames']:
        """
        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: Criteria for determining a SAN's match.
        """
        pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def match(self) -> 'outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatch':
        """
        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: Values sent must match the specified values exactly.
        """
        pulumi.set(__self__, "exacts", exacts)

    @property
    @pulumi.getter
    def exacts(self) -> Sequence[str]:
        """
        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: TLS validation context trust for an AWS Certificate Manager (ACM) certificate.
        :param 'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustFileArgs' file: TLS validation context trust for a local file certificate.
        :param 'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustSdsArgs' sds: 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']:
        """
        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']:
        """
        TLS validation context trust for a local file certificate.
        """
        return pulumi.get(self, "file")

    @property
    @pulumi.getter
    def sds(self) -> Optional['outputs.VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustSds']:
        """
        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 ARNs.
        """
        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 ARNs.
        """
        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: 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:
        """
        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: 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:
        """
        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: Port mapping information for the listener.
        :param 'VirtualNodeSpecListenerConnectionPoolArgs' connection_pool: Connection pool information for the listener.
        :param 'VirtualNodeSpecListenerHealthCheckArgs' health_check: Health check information for the listener.
        :param 'VirtualNodeSpecListenerOutlierDetectionArgs' outlier_detection: Outlier detection information for the listener.
        :param 'VirtualNodeSpecListenerTimeoutArgs' timeout: Timeouts for different protocols.
        :param 'VirtualNodeSpecListenerTlsArgs' tls: 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':
        """
        Port mapping information for the listener.
        """
        return pulumi.get(self, "port_mapping")

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

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

    @property
    @pulumi.getter(name="outlierDetection")
    def outlier_detection(self) -> Optional['outputs.VirtualNodeSpecListenerOutlierDetection']:
        """
        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']:
        """
        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: Number of consecutive successful health checks that must occur before declaring listener healthy.
        :param int interval_millis: Time period in milliseconds between each health check execution.
        :param str protocol: Protocol for the health check request. Valid values are `http`, `http2`, `tcp` and `grpc`.
        :param int timeout_millis: Amount of time to wait when receiving a response from the health check, in milliseconds.
        :param int unhealthy_threshold: Number of consecutive failed health checks that must occur before declaring a virtual node unhealthy.
        :param str path: Destination path for the health check request. This is only required if the specified protocol is `http` or `http2`.
        :param int port: 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:
        """
        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:
        """
        Time period in milliseconds between each health check execution.
        """
        return pulumi.get(self, "interval_millis")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        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:
        """
        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:
        """
        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]:
        """
        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]:
        """
        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: Base amount of time for which a host is ejected.
        :param 'VirtualNodeSpecListenerOutlierDetectionIntervalArgs' interval: 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':
        """
        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':
        """
        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: Unit of time. Valid values: `ms`, `s`.
        :param int value: 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:
        """
        Unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        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: Unit of time. Valid values: `ms`, `s`.
        :param int value: The specified value for the JSON. Must be between 1 and 100 characters in length.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

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

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        The specified value for the JSON. Must be between 1 and 100 characters in length.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class VirtualNodeSpecListenerPortMapping(dict):
    def __init__(__self__, *,
                 port: int,
                 protocol: str):
        """
        :param int port: Port used for the port mapping.
        :param str protocol: 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:
        """
        Port used for the port mapping.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        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: Idle timeout. An idle timeout bounds the amount of time that a connection may be idle.
        :param 'VirtualNodeSpecListenerTimeoutGrpcPerRequestArgs' per_request: 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']:
        """
        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']:
        """
        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: Unit of time. Valid values: `ms`, `s`.
        :param int value: 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:
        """
        Unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        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: Unit of time. Valid values: `ms`, `s`.
        :param int value: The specified value for the JSON. Must be between 1 and 100 characters in length.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

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

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        The specified value for the JSON. Must be between 1 and 100 characters in length.
        """
        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: Idle timeout. An idle timeout bounds the amount of time that a connection may be idle.
        :param 'VirtualNodeSpecListenerTimeoutHttp2PerRequestArgs' per_request: 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']:
        """
        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']:
        """
        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: Unit of time. Valid values: `ms`, `s`.
        :param int value: 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:
        """
        Unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        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: Unit of time. Valid values: `ms`, `s`.
        :param int value: The specified value for the JSON. Must be between 1 and 100 characters in length.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

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

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        The specified value for the JSON. Must be between 1 and 100 characters in length.
        """
        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: Idle timeout. An idle timeout bounds the amount of time that a connection may be idle.
        :param 'VirtualNodeSpecListenerTimeoutHttpPerRequestArgs' per_request: 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']:
        """
        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']:
        """
        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: Unit of time. Valid values: `ms`, `s`.
        :param int value: 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:
        """
        Unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        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: Unit of time. Valid values: `ms`, `s`.
        :param int value: The specified value for the JSON. Must be between 1 and 100 characters in length.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

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

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        The specified value for the JSON. Must be between 1 and 100 characters in length.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class VirtualNodeSpecListenerTimeoutTcp(dict):
    def __init__(__self__, *,
                 idle: Optional['outputs.VirtualNodeSpecListenerTimeoutTcpIdle'] = None):
        """
        :param 'VirtualNodeSpecListenerTimeoutTcpIdleArgs' idle: 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']:
        """
        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: Unit of time. Valid values: `ms`, `s`.
        :param int value: 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:
        """
        Unit of time. Valid values: `ms`, `s`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        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: Listener's TLS certificate.
        :param str mode: Listener's TLS mode. Valid values: `DISABLED`, `PERMISSIVE`, `STRICT`.
        :param 'VirtualNodeSpecListenerTlsValidationArgs' validation: 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':
        """
        Listener's TLS certificate.
        """
        return pulumi.get(self, "certificate")

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

    @property
    @pulumi.getter
    def validation(self) -> Optional['outputs.VirtualNodeSpecListenerTlsValidation']:
        """
        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: 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']:
        """
        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: ARN for the certificate.
        """
        pulumi.set(__self__, "certificate_arn", certificate_arn)

    @property
    @pulumi.getter(name="certificateArn")
    def certificate_arn(self) -> str:
        """
        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: 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: 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:
        """
        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:
        """
        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: 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:
        """
        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: TLS validation context trust.
        :param 'VirtualNodeSpecListenerTlsValidationSubjectAlternativeNamesArgs' subject_alternative_names: 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':
        """
        TLS validation context trust.
        """
        return pulumi.get(self, "trust")

    @property
    @pulumi.getter(name="subjectAlternativeNames")
    def subject_alternative_names(self) -> Optional['outputs.VirtualNodeSpecListenerTlsValidationSubjectAlternativeNames']:
        """
        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: Criteria for determining a SAN's match.
        """
        pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def match(self) -> 'outputs.VirtualNodeSpecListenerTlsValidationSubjectAlternativeNamesMatch':
        """
        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: Values sent must match the specified values exactly.
        """
        pulumi.set(__self__, "exacts", exacts)

    @property
    @pulumi.getter
    def exacts(self) -> Sequence[str]:
        """
        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: TLS validation context trust for a local file certificate.
        :param 'VirtualNodeSpecListenerTlsValidationTrustSdsArgs' sds: 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']:
        """
        TLS validation context trust for a local file certificate.
        """
        return pulumi.get(self, "file")

    @property
    @pulumi.getter
    def sds(self) -> Optional['outputs.VirtualNodeSpecListenerTlsValidationTrustSds']:
        """
        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: 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:
        """
        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: 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:
        """
        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: 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']:
        """
        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: 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']:
        """
        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,
                 format: Optional['outputs.VirtualNodeSpecLoggingAccessLogFileFormat'] = None):
        """
        :param str path: 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.
        :param 'VirtualNodeSpecLoggingAccessLogFileFormatArgs' format: The specified format for the logs.
        """
        pulumi.set(__self__, "path", path)
        if format is not None:
            pulumi.set(__self__, "format", format)

    @property
    @pulumi.getter
    def path(self) -> str:
        """
        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")

    @property
    @pulumi.getter
    def format(self) -> Optional['outputs.VirtualNodeSpecLoggingAccessLogFileFormat']:
        """
        The specified format for the logs.
        """
        return pulumi.get(self, "format")


@pulumi.output_type
class VirtualNodeSpecLoggingAccessLogFileFormat(dict):
    def __init__(__self__, *,
                 jsons: Optional[Sequence['outputs.VirtualNodeSpecLoggingAccessLogFileFormatJson']] = None,
                 text: Optional[str] = None):
        """
        :param Sequence['VirtualNodeSpecLoggingAccessLogFileFormatJsonArgs'] jsons: The logging format for JSON.
        :param str text: The logging format for text. Must be between 1 and 1000 characters in length.
        """
        if jsons is not None:
            pulumi.set(__self__, "jsons", jsons)
        if text is not None:
            pulumi.set(__self__, "text", text)

    @property
    @pulumi.getter
    def jsons(self) -> Optional[Sequence['outputs.VirtualNodeSpecLoggingAccessLogFileFormatJson']]:
        """
        The logging format for JSON.
        """
        return pulumi.get(self, "jsons")

    @property
    @pulumi.getter
    def text(self) -> Optional[str]:
        """
        The logging format for text. Must be between 1 and 1000 characters in length.
        """
        return pulumi.get(self, "text")


@pulumi.output_type
class VirtualNodeSpecLoggingAccessLogFileFormatJson(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        """
        :param str key: The specified key for the JSON. Must be between 1 and 100 characters in length.
        :param str value: The specified value for the JSON. Must be between 1 and 100 characters in length.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The specified key for the JSON. Must be between 1 and 100 characters in length.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The specified value for the JSON. Must be between 1 and 100 characters in length.
        """
        return pulumi.get(self, "value")


@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: Any AWS Cloud Map information for the virtual node.
        :param 'VirtualNodeSpecServiceDiscoveryDnsArgs' dns: 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']:
        """
        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']:
        """
        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: 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: 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: 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:
        """
        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:
        """
        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]]:
        """
        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: DNS host name for your virtual node.
        """
        pulumi.set(__self__, "hostname", hostname)

    @property
    @pulumi.getter
    def hostname(self) -> str:
        """
        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: 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':
        """
        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: Port mapping information for the listener.
        """
        pulumi.set(__self__, "port_mapping", port_mapping)

    @property
    @pulumi.getter(name="portMapping")
    def port_mapping(self) -> 'outputs.VirtualRouterSpecListenerPortMapping':
        """
        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: Port used for the port mapping.
        :param str protocol: 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:
        """
        Port used for the port mapping.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        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: 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']:
        """
        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: Virtual node associated with a virtual service.
        :param 'VirtualServiceSpecProviderVirtualRouterArgs' virtual_router: 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']:
        """
        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']:
        """
        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: 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:
        """
        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: 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:
        """
        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: 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']:
        """
        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: Egress filter type.
        """
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Egress filter type.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetRouteSpecResult(dict):
    def __init__(__self__, *,
                 grpc_routes: Sequence['outputs.GetRouteSpecGrpcRouteResult'],
                 http2_routes: Sequence['outputs.GetRouteSpecHttp2RouteResult'],
                 http_routes: Sequence['outputs.GetRouteSpecHttpRouteResult'],
                 priority: int,
                 tcp_routes: Sequence['outputs.GetRouteSpecTcpRouteResult']):
        """
        :param Sequence['GetRouteSpecGrpcRouteArgs'] grpc_routes: GRPC routing information for the route.
        :param Sequence['GetRouteSpecHttp2RouteArgs'] http2_routes: HTTP/2 routing information for the route.
        :param Sequence['GetRouteSpecHttpRouteArgs'] http_routes: HTTP routing information for the route.
        :param int priority: Priority for the route, between `0` and `1000`.
        :param Sequence['GetRouteSpecTcpRouteArgs'] tcp_routes: TCP routing information for the route.
        """
        pulumi.set(__self__, "grpc_routes", grpc_routes)
        pulumi.set(__self__, "http2_routes", http2_routes)
        pulumi.set(__self__, "http_routes", http_routes)
        pulumi.set(__self__, "priority", priority)
        pulumi.set(__self__, "tcp_routes", tcp_routes)

    @property
    @pulumi.getter(name="grpcRoutes")
    def grpc_routes(self) -> Sequence['outputs.GetRouteSpecGrpcRouteResult']:
        """
        GRPC routing information for the route.
        """
        return pulumi.get(self, "grpc_routes")

    @property
    @pulumi.getter(name="http2Routes")
    def http2_routes(self) -> Sequence['outputs.GetRouteSpecHttp2RouteResult']:
        """
        HTTP/2 routing information for the route.
        """
        return pulumi.get(self, "http2_routes")

    @property
    @pulumi.getter(name="httpRoutes")
    def http_routes(self) -> Sequence['outputs.GetRouteSpecHttpRouteResult']:
        """
        HTTP routing information for the route.
        """
        return pulumi.get(self, "http_routes")

    @property
    @pulumi.getter
    def priority(self) -> int:
        """
        Priority for the route, between `0` and `1000`.
        """
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter(name="tcpRoutes")
    def tcp_routes(self) -> Sequence['outputs.GetRouteSpecTcpRouteResult']:
        """
        TCP routing information for the route.
        """
        return pulumi.get(self, "tcp_routes")


@pulumi.output_type
class GetRouteSpecGrpcRouteResult(dict):
    def __init__(__self__, *,
                 actions: Sequence['outputs.GetRouteSpecGrpcRouteActionResult'],
                 matches: Sequence['outputs.GetRouteSpecGrpcRouteMatchResult'],
                 retry_policies: Sequence['outputs.GetRouteSpecGrpcRouteRetryPolicyResult'],
                 timeouts: Sequence['outputs.GetRouteSpecGrpcRouteTimeoutResult']):
        """
        :param Sequence['GetRouteSpecGrpcRouteActionArgs'] actions: Action to take if a match is determined.
        :param Sequence['GetRouteSpecGrpcRouteMatchArgs'] matches: Criteria for determining an HTTP request match.
        :param Sequence['GetRouteSpecGrpcRouteRetryPolicyArgs'] retry_policies: Retry policy.
        :param Sequence['GetRouteSpecGrpcRouteTimeoutArgs'] timeouts: Types of timeouts.
        """
        pulumi.set(__self__, "actions", actions)
        pulumi.set(__self__, "matches", matches)
        pulumi.set(__self__, "retry_policies", retry_policies)
        pulumi.set(__self__, "timeouts", timeouts)

    @property
    @pulumi.getter
    def actions(self) -> Sequence['outputs.GetRouteSpecGrpcRouteActionResult']:
        """
        Action to take if a match is determined.
        """
        return pulumi.get(self, "actions")

    @property
    @pulumi.getter
    def matches(self) -> Sequence['outputs.GetRouteSpecGrpcRouteMatchResult']:
        """
        Criteria for determining an HTTP request match.
        """
        return pulumi.get(self, "matches")

    @property
    @pulumi.getter(name="retryPolicies")
    def retry_policies(self) -> Sequence['outputs.GetRouteSpecGrpcRouteRetryPolicyResult']:
        """
        Retry policy.
        """
        return pulumi.get(self, "retry_policies")

    @property
    @pulumi.getter
    def timeouts(self) -> Sequence['outputs.GetRouteSpecGrpcRouteTimeoutResult']:
        """
        Types of timeouts.
        """
        return pulumi.get(self, "timeouts")


@pulumi.output_type
class GetRouteSpecGrpcRouteActionResult(dict):
    def __init__(__self__, *,
                 weighted_targets: Sequence['outputs.GetRouteSpecGrpcRouteActionWeightedTargetResult']):
        pulumi.set(__self__, "weighted_targets", weighted_targets)

    @property
    @pulumi.getter(name="weightedTargets")
    def weighted_targets(self) -> Sequence['outputs.GetRouteSpecGrpcRouteActionWeightedTargetResult']:
        return pulumi.get(self, "weighted_targets")


@pulumi.output_type
class GetRouteSpecGrpcRouteActionWeightedTargetResult(dict):
    def __init__(__self__, *,
                 port: int,
                 virtual_node: str,
                 weight: int):
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "virtual_node", virtual_node)
        pulumi.set(__self__, "weight", weight)

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

    @property
    @pulumi.getter(name="virtualNode")
    def virtual_node(self) -> str:
        return pulumi.get(self, "virtual_node")

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


@pulumi.output_type
class GetRouteSpecGrpcRouteMatchResult(dict):
    def __init__(__self__, *,
                 metadatas: Sequence['outputs.GetRouteSpecGrpcRouteMatchMetadataResult'],
                 method_name: str,
                 port: int,
                 prefix: str,
                 service_name: str):
        pulumi.set(__self__, "metadatas", metadatas)
        pulumi.set(__self__, "method_name", method_name)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "prefix", prefix)
        pulumi.set(__self__, "service_name", service_name)

    @property
    @pulumi.getter
    def metadatas(self) -> Sequence['outputs.GetRouteSpecGrpcRouteMatchMetadataResult']:
        return pulumi.get(self, "metadatas")

    @property
    @pulumi.getter(name="methodName")
    def method_name(self) -> str:
        return pulumi.get(self, "method_name")

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

    @property
    @pulumi.getter
    def prefix(self) -> str:
        return pulumi.get(self, "prefix")

    @property
    @pulumi.getter(name="serviceName")
    def service_name(self) -> str:
        return pulumi.get(self, "service_name")


@pulumi.output_type
class GetRouteSpecGrpcRouteMatchMetadataResult(dict):
    def __init__(__self__, *,
                 invert: bool,
                 matches: Sequence['outputs.GetRouteSpecGrpcRouteMatchMetadataMatchResult'],
                 name: str):
        """
        :param Sequence['GetRouteSpecGrpcRouteMatchMetadataMatchArgs'] matches: Criteria for determining an HTTP request match.
        :param str name: Name of the route.
        """
        pulumi.set(__self__, "invert", invert)
        pulumi.set(__self__, "matches", matches)
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def invert(self) -> bool:
        return pulumi.get(self, "invert")

    @property
    @pulumi.getter
    def matches(self) -> Sequence['outputs.GetRouteSpecGrpcRouteMatchMetadataMatchResult']:
        """
        Criteria for determining an HTTP request match.
        """
        return pulumi.get(self, "matches")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the route.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class GetRouteSpecGrpcRouteMatchMetadataMatchResult(dict):
    def __init__(__self__, *,
                 exact: str,
                 prefix: str,
                 ranges: Sequence['outputs.GetRouteSpecGrpcRouteMatchMetadataMatchRangeResult'],
                 regex: str,
                 suffix: str):
        pulumi.set(__self__, "exact", exact)
        pulumi.set(__self__, "prefix", prefix)
        pulumi.set(__self__, "ranges", ranges)
        pulumi.set(__self__, "regex", regex)
        pulumi.set(__self__, "suffix", suffix)

    @property
    @pulumi.getter
    def exact(self) -> str:
        return pulumi.get(self, "exact")

    @property
    @pulumi.getter
    def prefix(self) -> str:
        return pulumi.get(self, "prefix")

    @property
    @pulumi.getter
    def ranges(self) -> Sequence['outputs.GetRouteSpecGrpcRouteMatchMetadataMatchRangeResult']:
        return pulumi.get(self, "ranges")

    @property
    @pulumi.getter
    def regex(self) -> str:
        return pulumi.get(self, "regex")

    @property
    @pulumi.getter
    def suffix(self) -> str:
        return pulumi.get(self, "suffix")


@pulumi.output_type
class GetRouteSpecGrpcRouteMatchMetadataMatchRangeResult(dict):
    def __init__(__self__, *,
                 end: int,
                 start: int):
        pulumi.set(__self__, "end", end)
        pulumi.set(__self__, "start", start)

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

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


@pulumi.output_type
class GetRouteSpecGrpcRouteRetryPolicyResult(dict):
    def __init__(__self__, *,
                 grpc_retry_events: Sequence[str],
                 http_retry_events: Sequence[str],
                 max_retries: int,
                 per_retry_timeouts: Sequence['outputs.GetRouteSpecGrpcRouteRetryPolicyPerRetryTimeoutResult'],
                 tcp_retry_events: Sequence[str]):
        pulumi.set(__self__, "grpc_retry_events", grpc_retry_events)
        pulumi.set(__self__, "http_retry_events", http_retry_events)
        pulumi.set(__self__, "max_retries", max_retries)
        pulumi.set(__self__, "per_retry_timeouts", per_retry_timeouts)
        pulumi.set(__self__, "tcp_retry_events", tcp_retry_events)

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

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

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

    @property
    @pulumi.getter(name="perRetryTimeouts")
    def per_retry_timeouts(self) -> Sequence['outputs.GetRouteSpecGrpcRouteRetryPolicyPerRetryTimeoutResult']:
        return pulumi.get(self, "per_retry_timeouts")

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


@pulumi.output_type
class GetRouteSpecGrpcRouteRetryPolicyPerRetryTimeoutResult(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        return pulumi.get(self, "unit")

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


@pulumi.output_type
class GetRouteSpecGrpcRouteTimeoutResult(dict):
    def __init__(__self__, *,
                 idles: Sequence['outputs.GetRouteSpecGrpcRouteTimeoutIdleResult'],
                 per_requests: Sequence['outputs.GetRouteSpecGrpcRouteTimeoutPerRequestResult']):
        pulumi.set(__self__, "idles", idles)
        pulumi.set(__self__, "per_requests", per_requests)

    @property
    @pulumi.getter
    def idles(self) -> Sequence['outputs.GetRouteSpecGrpcRouteTimeoutIdleResult']:
        return pulumi.get(self, "idles")

    @property
    @pulumi.getter(name="perRequests")
    def per_requests(self) -> Sequence['outputs.GetRouteSpecGrpcRouteTimeoutPerRequestResult']:
        return pulumi.get(self, "per_requests")


@pulumi.output_type
class GetRouteSpecGrpcRouteTimeoutIdleResult(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        return pulumi.get(self, "unit")

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


@pulumi.output_type
class GetRouteSpecGrpcRouteTimeoutPerRequestResult(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        return pulumi.get(self, "unit")

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


@pulumi.output_type
class GetRouteSpecHttp2RouteResult(dict):
    def __init__(__self__, *,
                 actions: Sequence['outputs.GetRouteSpecHttp2RouteActionResult'],
                 matches: Sequence['outputs.GetRouteSpecHttp2RouteMatchResult'],
                 retry_policies: Sequence['outputs.GetRouteSpecHttp2RouteRetryPolicyResult'],
                 timeouts: Sequence['outputs.GetRouteSpecHttp2RouteTimeoutResult']):
        """
        :param Sequence['GetRouteSpecHttp2RouteActionArgs'] actions: Action to take if a match is determined.
        :param Sequence['GetRouteSpecHttp2RouteMatchArgs'] matches: Criteria for determining an HTTP request match.
        :param Sequence['GetRouteSpecHttp2RouteRetryPolicyArgs'] retry_policies: Retry policy.
        :param Sequence['GetRouteSpecHttp2RouteTimeoutArgs'] timeouts: Types of timeouts.
        """
        pulumi.set(__self__, "actions", actions)
        pulumi.set(__self__, "matches", matches)
        pulumi.set(__self__, "retry_policies", retry_policies)
        pulumi.set(__self__, "timeouts", timeouts)

    @property
    @pulumi.getter
    def actions(self) -> Sequence['outputs.GetRouteSpecHttp2RouteActionResult']:
        """
        Action to take if a match is determined.
        """
        return pulumi.get(self, "actions")

    @property
    @pulumi.getter
    def matches(self) -> Sequence['outputs.GetRouteSpecHttp2RouteMatchResult']:
        """
        Criteria for determining an HTTP request match.
        """
        return pulumi.get(self, "matches")

    @property
    @pulumi.getter(name="retryPolicies")
    def retry_policies(self) -> Sequence['outputs.GetRouteSpecHttp2RouteRetryPolicyResult']:
        """
        Retry policy.
        """
        return pulumi.get(self, "retry_policies")

    @property
    @pulumi.getter
    def timeouts(self) -> Sequence['outputs.GetRouteSpecHttp2RouteTimeoutResult']:
        """
        Types of timeouts.
        """
        return pulumi.get(self, "timeouts")


@pulumi.output_type
class GetRouteSpecHttp2RouteActionResult(dict):
    def __init__(__self__, *,
                 weighted_targets: Sequence['outputs.GetRouteSpecHttp2RouteActionWeightedTargetResult']):
        pulumi.set(__self__, "weighted_targets", weighted_targets)

    @property
    @pulumi.getter(name="weightedTargets")
    def weighted_targets(self) -> Sequence['outputs.GetRouteSpecHttp2RouteActionWeightedTargetResult']:
        return pulumi.get(self, "weighted_targets")


@pulumi.output_type
class GetRouteSpecHttp2RouteActionWeightedTargetResult(dict):
    def __init__(__self__, *,
                 port: int,
                 virtual_node: str,
                 weight: int):
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "virtual_node", virtual_node)
        pulumi.set(__self__, "weight", weight)

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

    @property
    @pulumi.getter(name="virtualNode")
    def virtual_node(self) -> str:
        return pulumi.get(self, "virtual_node")

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


@pulumi.output_type
class GetRouteSpecHttp2RouteMatchResult(dict):
    def __init__(__self__, *,
                 headers: Sequence['outputs.GetRouteSpecHttp2RouteMatchHeaderResult'],
                 method: str,
                 port: int,
                 prefix: str,
                 scheme: str):
        pulumi.set(__self__, "headers", headers)
        pulumi.set(__self__, "method", method)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "prefix", prefix)
        pulumi.set(__self__, "scheme", scheme)

    @property
    @pulumi.getter
    def headers(self) -> Sequence['outputs.GetRouteSpecHttp2RouteMatchHeaderResult']:
        return pulumi.get(self, "headers")

    @property
    @pulumi.getter
    def method(self) -> str:
        return pulumi.get(self, "method")

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

    @property
    @pulumi.getter
    def prefix(self) -> str:
        return pulumi.get(self, "prefix")

    @property
    @pulumi.getter
    def scheme(self) -> str:
        return pulumi.get(self, "scheme")


@pulumi.output_type
class GetRouteSpecHttp2RouteMatchHeaderResult(dict):
    def __init__(__self__, *,
                 invert: bool,
                 matches: Sequence['outputs.GetRouteSpecHttp2RouteMatchHeaderMatchResult'],
                 name: str):
        """
        :param Sequence['GetRouteSpecHttp2RouteMatchHeaderMatchArgs'] matches: Criteria for determining an HTTP request match.
        :param str name: Name of the route.
        """
        pulumi.set(__self__, "invert", invert)
        pulumi.set(__self__, "matches", matches)
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def invert(self) -> bool:
        return pulumi.get(self, "invert")

    @property
    @pulumi.getter
    def matches(self) -> Sequence['outputs.GetRouteSpecHttp2RouteMatchHeaderMatchResult']:
        """
        Criteria for determining an HTTP request match.
        """
        return pulumi.get(self, "matches")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the route.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class GetRouteSpecHttp2RouteMatchHeaderMatchResult(dict):
    def __init__(__self__, *,
                 exact: str,
                 prefix: str,
                 ranges: Sequence['outputs.GetRouteSpecHttp2RouteMatchHeaderMatchRangeResult'],
                 regex: str,
                 suffix: str):
        pulumi.set(__self__, "exact", exact)
        pulumi.set(__self__, "prefix", prefix)
        pulumi.set(__self__, "ranges", ranges)
        pulumi.set(__self__, "regex", regex)
        pulumi.set(__self__, "suffix", suffix)

    @property
    @pulumi.getter
    def exact(self) -> str:
        return pulumi.get(self, "exact")

    @property
    @pulumi.getter
    def prefix(self) -> str:
        return pulumi.get(self, "prefix")

    @property
    @pulumi.getter
    def ranges(self) -> Sequence['outputs.GetRouteSpecHttp2RouteMatchHeaderMatchRangeResult']:
        return pulumi.get(self, "ranges")

    @property
    @pulumi.getter
    def regex(self) -> str:
        return pulumi.get(self, "regex")

    @property
    @pulumi.getter
    def suffix(self) -> str:
        return pulumi.get(self, "suffix")


@pulumi.output_type
class GetRouteSpecHttp2RouteMatchHeaderMatchRangeResult(dict):
    def __init__(__self__, *,
                 end: int,
                 start: int):
        pulumi.set(__self__, "end", end)
        pulumi.set(__self__, "start", start)

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

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


@pulumi.output_type
class GetRouteSpecHttp2RouteRetryPolicyResult(dict):
    def __init__(__self__, *,
                 http_retry_events: Sequence[str],
                 max_retries: int,
                 per_retry_timeouts: Sequence['outputs.GetRouteSpecHttp2RouteRetryPolicyPerRetryTimeoutResult'],
                 tcp_retry_events: Sequence[str]):
        pulumi.set(__self__, "http_retry_events", http_retry_events)
        pulumi.set(__self__, "max_retries", max_retries)
        pulumi.set(__self__, "per_retry_timeouts", per_retry_timeouts)
        pulumi.set(__self__, "tcp_retry_events", tcp_retry_events)

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

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

    @property
    @pulumi.getter(name="perRetryTimeouts")
    def per_retry_timeouts(self) -> Sequence['outputs.GetRouteSpecHttp2RouteRetryPolicyPerRetryTimeoutResult']:
        return pulumi.get(self, "per_retry_timeouts")

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


@pulumi.output_type
class GetRouteSpecHttp2RouteRetryPolicyPerRetryTimeoutResult(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        return pulumi.get(self, "unit")

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


@pulumi.output_type
class GetRouteSpecHttp2RouteTimeoutResult(dict):
    def __init__(__self__, *,
                 idles: Sequence['outputs.GetRouteSpecHttp2RouteTimeoutIdleResult'],
                 per_requests: Sequence['outputs.GetRouteSpecHttp2RouteTimeoutPerRequestResult']):
        pulumi.set(__self__, "idles", idles)
        pulumi.set(__self__, "per_requests", per_requests)

    @property
    @pulumi.getter
    def idles(self) -> Sequence['outputs.GetRouteSpecHttp2RouteTimeoutIdleResult']:
        return pulumi.get(self, "idles")

    @property
    @pulumi.getter(name="perRequests")
    def per_requests(self) -> Sequence['outputs.GetRouteSpecHttp2RouteTimeoutPerRequestResult']:
        return pulumi.get(self, "per_requests")


@pulumi.output_type
class GetRouteSpecHttp2RouteTimeoutIdleResult(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        return pulumi.get(self, "unit")

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


@pulumi.output_type
class GetRouteSpecHttp2RouteTimeoutPerRequestResult(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        return pulumi.get(self, "unit")

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


@pulumi.output_type
class GetRouteSpecHttpRouteResult(dict):
    def __init__(__self__, *,
                 actions: Sequence['outputs.GetRouteSpecHttpRouteActionResult'],
                 matches: Sequence['outputs.GetRouteSpecHttpRouteMatchResult'],
                 retry_policies: Sequence['outputs.GetRouteSpecHttpRouteRetryPolicyResult'],
                 timeouts: Sequence['outputs.GetRouteSpecHttpRouteTimeoutResult']):
        """
        :param Sequence['GetRouteSpecHttpRouteActionArgs'] actions: Action to take if a match is determined.
        :param Sequence['GetRouteSpecHttpRouteMatchArgs'] matches: Criteria for determining an HTTP request match.
        :param Sequence['GetRouteSpecHttpRouteRetryPolicyArgs'] retry_policies: Retry policy.
        :param Sequence['GetRouteSpecHttpRouteTimeoutArgs'] timeouts: Types of timeouts.
        """
        pulumi.set(__self__, "actions", actions)
        pulumi.set(__self__, "matches", matches)
        pulumi.set(__self__, "retry_policies", retry_policies)
        pulumi.set(__self__, "timeouts", timeouts)

    @property
    @pulumi.getter
    def actions(self) -> Sequence['outputs.GetRouteSpecHttpRouteActionResult']:
        """
        Action to take if a match is determined.
        """
        return pulumi.get(self, "actions")

    @property
    @pulumi.getter
    def matches(self) -> Sequence['outputs.GetRouteSpecHttpRouteMatchResult']:
        """
        Criteria for determining an HTTP request match.
        """
        return pulumi.get(self, "matches")

    @property
    @pulumi.getter(name="retryPolicies")
    def retry_policies(self) -> Sequence['outputs.GetRouteSpecHttpRouteRetryPolicyResult']:
        """
        Retry policy.
        """
        return pulumi.get(self, "retry_policies")

    @property
    @pulumi.getter
    def timeouts(self) -> Sequence['outputs.GetRouteSpecHttpRouteTimeoutResult']:
        """
        Types of timeouts.
        """
        return pulumi.get(self, "timeouts")


@pulumi.output_type
class GetRouteSpecHttpRouteActionResult(dict):
    def __init__(__self__, *,
                 weighted_targets: Sequence['outputs.GetRouteSpecHttpRouteActionWeightedTargetResult']):
        pulumi.set(__self__, "weighted_targets", weighted_targets)

    @property
    @pulumi.getter(name="weightedTargets")
    def weighted_targets(self) -> Sequence['outputs.GetRouteSpecHttpRouteActionWeightedTargetResult']:
        return pulumi.get(self, "weighted_targets")


@pulumi.output_type
class GetRouteSpecHttpRouteActionWeightedTargetResult(dict):
    def __init__(__self__, *,
                 port: int,
                 virtual_node: str,
                 weight: int):
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "virtual_node", virtual_node)
        pulumi.set(__self__, "weight", weight)

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

    @property
    @pulumi.getter(name="virtualNode")
    def virtual_node(self) -> str:
        return pulumi.get(self, "virtual_node")

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


@pulumi.output_type
class GetRouteSpecHttpRouteMatchResult(dict):
    def __init__(__self__, *,
                 headers: Sequence['outputs.GetRouteSpecHttpRouteMatchHeaderResult'],
                 method: str,
                 port: int,
                 prefix: str,
                 scheme: str):
        pulumi.set(__self__, "headers", headers)
        pulumi.set(__self__, "method", method)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "prefix", prefix)
        pulumi.set(__self__, "scheme", scheme)

    @property
    @pulumi.getter
    def headers(self) -> Sequence['outputs.GetRouteSpecHttpRouteMatchHeaderResult']:
        return pulumi.get(self, "headers")

    @property
    @pulumi.getter
    def method(self) -> str:
        return pulumi.get(self, "method")

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

    @property
    @pulumi.getter
    def prefix(self) -> str:
        return pulumi.get(self, "prefix")

    @property
    @pulumi.getter
    def scheme(self) -> str:
        return pulumi.get(self, "scheme")


@pulumi.output_type
class GetRouteSpecHttpRouteMatchHeaderResult(dict):
    def __init__(__self__, *,
                 invert: bool,
                 matches: Sequence['outputs.GetRouteSpecHttpRouteMatchHeaderMatchResult'],
                 name: str):
        """
        :param Sequence['GetRouteSpecHttpRouteMatchHeaderMatchArgs'] matches: Criteria for determining an HTTP request match.
        :param str name: Name of the route.
        """
        pulumi.set(__self__, "invert", invert)
        pulumi.set(__self__, "matches", matches)
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def invert(self) -> bool:
        return pulumi.get(self, "invert")

    @property
    @pulumi.getter
    def matches(self) -> Sequence['outputs.GetRouteSpecHttpRouteMatchHeaderMatchResult']:
        """
        Criteria for determining an HTTP request match.
        """
        return pulumi.get(self, "matches")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the route.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class GetRouteSpecHttpRouteMatchHeaderMatchResult(dict):
    def __init__(__self__, *,
                 exact: str,
                 prefix: str,
                 ranges: Sequence['outputs.GetRouteSpecHttpRouteMatchHeaderMatchRangeResult'],
                 regex: str,
                 suffix: str):
        pulumi.set(__self__, "exact", exact)
        pulumi.set(__self__, "prefix", prefix)
        pulumi.set(__self__, "ranges", ranges)
        pulumi.set(__self__, "regex", regex)
        pulumi.set(__self__, "suffix", suffix)

    @property
    @pulumi.getter
    def exact(self) -> str:
        return pulumi.get(self, "exact")

    @property
    @pulumi.getter
    def prefix(self) -> str:
        return pulumi.get(self, "prefix")

    @property
    @pulumi.getter
    def ranges(self) -> Sequence['outputs.GetRouteSpecHttpRouteMatchHeaderMatchRangeResult']:
        return pulumi.get(self, "ranges")

    @property
    @pulumi.getter
    def regex(self) -> str:
        return pulumi.get(self, "regex")

    @property
    @pulumi.getter
    def suffix(self) -> str:
        return pulumi.get(self, "suffix")


@pulumi.output_type
class GetRouteSpecHttpRouteMatchHeaderMatchRangeResult(dict):
    def __init__(__self__, *,
                 end: int,
                 start: int):
        pulumi.set(__self__, "end", end)
        pulumi.set(__self__, "start", start)

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

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


@pulumi.output_type
class GetRouteSpecHttpRouteRetryPolicyResult(dict):
    def __init__(__self__, *,
                 http_retry_events: Sequence[str],
                 max_retries: int,
                 per_retry_timeouts: Sequence['outputs.GetRouteSpecHttpRouteRetryPolicyPerRetryTimeoutResult'],
                 tcp_retry_events: Sequence[str]):
        pulumi.set(__self__, "http_retry_events", http_retry_events)
        pulumi.set(__self__, "max_retries", max_retries)
        pulumi.set(__self__, "per_retry_timeouts", per_retry_timeouts)
        pulumi.set(__self__, "tcp_retry_events", tcp_retry_events)

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

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

    @property
    @pulumi.getter(name="perRetryTimeouts")
    def per_retry_timeouts(self) -> Sequence['outputs.GetRouteSpecHttpRouteRetryPolicyPerRetryTimeoutResult']:
        return pulumi.get(self, "per_retry_timeouts")

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


@pulumi.output_type
class GetRouteSpecHttpRouteRetryPolicyPerRetryTimeoutResult(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        return pulumi.get(self, "unit")

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


@pulumi.output_type
class GetRouteSpecHttpRouteTimeoutResult(dict):
    def __init__(__self__, *,
                 idles: Sequence['outputs.GetRouteSpecHttpRouteTimeoutIdleResult'],
                 per_requests: Sequence['outputs.GetRouteSpecHttpRouteTimeoutPerRequestResult']):
        pulumi.set(__self__, "idles", idles)
        pulumi.set(__self__, "per_requests", per_requests)

    @property
    @pulumi.getter
    def idles(self) -> Sequence['outputs.GetRouteSpecHttpRouteTimeoutIdleResult']:
        return pulumi.get(self, "idles")

    @property
    @pulumi.getter(name="perRequests")
    def per_requests(self) -> Sequence['outputs.GetRouteSpecHttpRouteTimeoutPerRequestResult']:
        return pulumi.get(self, "per_requests")


@pulumi.output_type
class GetRouteSpecHttpRouteTimeoutIdleResult(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        return pulumi.get(self, "unit")

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


@pulumi.output_type
class GetRouteSpecHttpRouteTimeoutPerRequestResult(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        return pulumi.get(self, "unit")

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


@pulumi.output_type
class GetRouteSpecTcpRouteResult(dict):
    def __init__(__self__, *,
                 actions: Sequence['outputs.GetRouteSpecTcpRouteActionResult'],
                 matches: Sequence['outputs.GetRouteSpecTcpRouteMatchResult'],
                 timeouts: Sequence['outputs.GetRouteSpecTcpRouteTimeoutResult']):
        """
        :param Sequence['GetRouteSpecTcpRouteActionArgs'] actions: Action to take if a match is determined.
        :param Sequence['GetRouteSpecTcpRouteMatchArgs'] matches: Criteria for determining an HTTP request match.
        :param Sequence['GetRouteSpecTcpRouteTimeoutArgs'] timeouts: Types of timeouts.
        """
        pulumi.set(__self__, "actions", actions)
        pulumi.set(__self__, "matches", matches)
        pulumi.set(__self__, "timeouts", timeouts)

    @property
    @pulumi.getter
    def actions(self) -> Sequence['outputs.GetRouteSpecTcpRouteActionResult']:
        """
        Action to take if a match is determined.
        """
        return pulumi.get(self, "actions")

    @property
    @pulumi.getter
    def matches(self) -> Sequence['outputs.GetRouteSpecTcpRouteMatchResult']:
        """
        Criteria for determining an HTTP request match.
        """
        return pulumi.get(self, "matches")

    @property
    @pulumi.getter
    def timeouts(self) -> Sequence['outputs.GetRouteSpecTcpRouteTimeoutResult']:
        """
        Types of timeouts.
        """
        return pulumi.get(self, "timeouts")


@pulumi.output_type
class GetRouteSpecTcpRouteActionResult(dict):
    def __init__(__self__, *,
                 weighted_targets: Sequence['outputs.GetRouteSpecTcpRouteActionWeightedTargetResult']):
        pulumi.set(__self__, "weighted_targets", weighted_targets)

    @property
    @pulumi.getter(name="weightedTargets")
    def weighted_targets(self) -> Sequence['outputs.GetRouteSpecTcpRouteActionWeightedTargetResult']:
        return pulumi.get(self, "weighted_targets")


@pulumi.output_type
class GetRouteSpecTcpRouteActionWeightedTargetResult(dict):
    def __init__(__self__, *,
                 port: int,
                 virtual_node: str,
                 weight: int):
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "virtual_node", virtual_node)
        pulumi.set(__self__, "weight", weight)

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

    @property
    @pulumi.getter(name="virtualNode")
    def virtual_node(self) -> str:
        return pulumi.get(self, "virtual_node")

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


@pulumi.output_type
class GetRouteSpecTcpRouteMatchResult(dict):
    def __init__(__self__, *,
                 port: int):
        pulumi.set(__self__, "port", port)

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


@pulumi.output_type
class GetRouteSpecTcpRouteTimeoutResult(dict):
    def __init__(__self__, *,
                 idles: Sequence['outputs.GetRouteSpecTcpRouteTimeoutIdleResult']):
        pulumi.set(__self__, "idles", idles)

    @property
    @pulumi.getter
    def idles(self) -> Sequence['outputs.GetRouteSpecTcpRouteTimeoutIdleResult']:
        return pulumi.get(self, "idles")


@pulumi.output_type
class GetRouteSpecTcpRouteTimeoutIdleResult(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: int):
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        return pulumi.get(self, "unit")

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


@pulumi.output_type
class GetVirtualGatewaySpecResult(dict):
    def __init__(__self__, *,
                 backend_defaults: Sequence['outputs.GetVirtualGatewaySpecBackendDefaultResult'],
                 listeners: Sequence['outputs.GetVirtualGatewaySpecListenerResult'],
                 loggings: Sequence['outputs.GetVirtualGatewaySpecLoggingResult']):
        """
        :param Sequence['GetVirtualGatewaySpecBackendDefaultArgs'] backend_defaults: Defaults for backends.
        :param Sequence['GetVirtualGatewaySpecListenerArgs'] listeners: Listeners that the mesh endpoint is expected to receive inbound traffic from. You can specify one listener.
        :param Sequence['GetVirtualGatewaySpecLoggingArgs'] loggings: Inbound and outbound access logging information for the virtual gateway.
        """
        pulumi.set(__self__, "backend_defaults", backend_defaults)
        pulumi.set(__self__, "listeners", listeners)
        pulumi.set(__self__, "loggings", loggings)

    @property
    @pulumi.getter(name="backendDefaults")
    def backend_defaults(self) -> Sequence['outputs.GetVirtualGatewaySpecBackendDefaultResult']:
        """
        Defaults for backends.
        """
        return pulumi.get(self, "backend_defaults")

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

    @property
    @pulumi.getter
    def loggings(self) -> Sequence['outputs.GetVirtualGatewaySpecLoggingResult']:
        """
        Inbound and outbound access logging information for the virtual gateway.
        """
        return pulumi.get(self, "loggings")


@pulumi.output_type
class GetVirtualGatewaySpecBackendDefaultResult(dict):
    def __init__(__self__, *,
                 client_policies: Sequence['outputs.GetVirtualGatewaySpecBackendDefaultClientPolicyResult']):
        """
        :param Sequence['GetVirtualGatewaySpecBackendDefaultClientPolicyArgs'] client_policies: Default client policy for virtual gateway backends.
        """
        pulumi.set(__self__, "client_policies", client_policies)

    @property
    @pulumi.getter(name="clientPolicies")
    def client_policies(self) -> Sequence['outputs.GetVirtualGatewaySpecBackendDefaultClientPolicyResult']:
        """
        Default client policy for virtual gateway backends.
        """
        return pulumi.get(self, "client_policies")


@pulumi.output_type
class GetVirtualGatewaySpecBackendDefaultClientPolicyResult(dict):
    def __init__(__self__, *,
                 tls: Sequence['outputs.GetVirtualGatewaySpecBackendDefaultClientPolicyTlResult']):
        """
        :param Sequence['GetVirtualGatewaySpecBackendDefaultClientPolicyTlArgs'] tls: Transport Layer Security (TLS) properties for the listener
        """
        pulumi.set(__self__, "tls", tls)

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


@pulumi.output_type
class GetVirtualGatewaySpecBackendDefaultClientPolicyTlResult(dict):
    def __init__(__self__, *,
                 certificates: Sequence['outputs.GetVirtualGatewaySpecBackendDefaultClientPolicyTlCertificateResult'],
                 enforce: bool,
                 ports: Sequence[int],
                 validations: Sequence['outputs.GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationResult']):
        """
        :param Sequence['GetVirtualGatewaySpecBackendDefaultClientPolicyTlCertificateArgs'] certificates: 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.
        :param Sequence['GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationArgs'] validations: Listener's Transport Layer Security (TLS) validation context.
        """
        pulumi.set(__self__, "certificates", certificates)
        pulumi.set(__self__, "enforce", enforce)
        pulumi.set(__self__, "ports", ports)
        pulumi.set(__self__, "validations", validations)

    @property
    @pulumi.getter
    def certificates(self) -> Sequence['outputs.GetVirtualGatewaySpecBackendDefaultClientPolicyTlCertificateResult']:
        """
        Listener's TLS certificate.
        """
        return pulumi.get(self, "certificates")

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

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

    @property
    @pulumi.getter
    def validations(self) -> Sequence['outputs.GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationResult']:
        """
        Listener's Transport Layer Security (TLS) validation context.
        """
        return pulumi.get(self, "validations")


@pulumi.output_type
class GetVirtualGatewaySpecBackendDefaultClientPolicyTlCertificateResult(dict):
    def __init__(__self__, *,
                 files: Sequence['outputs.GetVirtualGatewaySpecBackendDefaultClientPolicyTlCertificateFileResult'],
                 sds: Sequence['outputs.GetVirtualGatewaySpecBackendDefaultClientPolicyTlCertificateSdResult']):
        """
        :param Sequence['GetVirtualGatewaySpecBackendDefaultClientPolicyTlCertificateFileArgs'] files: TLS validation context trust for a local file certificate.
        :param Sequence['GetVirtualGatewaySpecBackendDefaultClientPolicyTlCertificateSdArgs'] sds: TLS validation context trust for a [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        pulumi.set(__self__, "files", files)
        pulumi.set(__self__, "sds", sds)

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

    @property
    @pulumi.getter
    def sds(self) -> Sequence['outputs.GetVirtualGatewaySpecBackendDefaultClientPolicyTlCertificateSdResult']:
        """
        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 GetVirtualGatewaySpecBackendDefaultClientPolicyTlCertificateFileResult(dict):
    def __init__(__self__, *,
                 certificate_chain: str,
                 private_key: str):
        """
        :param str certificate_chain: 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: 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:
        """
        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:
        """
        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 GetVirtualGatewaySpecBackendDefaultClientPolicyTlCertificateSdResult(dict):
    def __init__(__self__, *,
                 secret_name: str):
        """
        :param str secret_name: 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:
        """
        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 GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationResult(dict):
    def __init__(__self__, *,
                 subject_alternative_names: Sequence['outputs.GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationSubjectAlternativeNameResult'],
                 trusts: Sequence['outputs.GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationTrustResult']):
        """
        :param Sequence['GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationSubjectAlternativeNameArgs'] subject_alternative_names: SANs for a virtual gateway's listener's Transport Layer Security (TLS) validation context.
        :param Sequence['GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationTrustArgs'] trusts: TLS validation context trust.
        """
        pulumi.set(__self__, "subject_alternative_names", subject_alternative_names)
        pulumi.set(__self__, "trusts", trusts)

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

    @property
    @pulumi.getter
    def trusts(self) -> Sequence['outputs.GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationTrustResult']:
        """
        TLS validation context trust.
        """
        return pulumi.get(self, "trusts")


@pulumi.output_type
class GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationSubjectAlternativeNameResult(dict):
    def __init__(__self__, *,
                 matches: Sequence['outputs.GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationSubjectAlternativeNameMatchResult']):
        """
        :param Sequence['GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationSubjectAlternativeNameMatchArgs'] matches: Criteria for determining a SAN's match.
        """
        pulumi.set(__self__, "matches", matches)

    @property
    @pulumi.getter
    def matches(self) -> Sequence['outputs.GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationSubjectAlternativeNameMatchResult']:
        """
        Criteria for determining a SAN's match.
        """
        return pulumi.get(self, "matches")


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

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


@pulumi.output_type
class GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationTrustResult(dict):
    def __init__(__self__, *,
                 acms: Sequence['outputs.GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationTrustAcmResult'],
                 files: Sequence['outputs.GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationTrustFileResult'],
                 sds: Sequence['outputs.GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationTrustSdResult']):
        """
        :param Sequence['GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationTrustAcmArgs'] acms: An AWS Certificate Manager (ACM) certificate.
        :param Sequence['GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationTrustFileArgs'] files: TLS validation context trust for a local file certificate.
        :param Sequence['GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationTrustSdArgs'] sds: TLS validation context trust for a [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        pulumi.set(__self__, "acms", acms)
        pulumi.set(__self__, "files", files)
        pulumi.set(__self__, "sds", sds)

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

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

    @property
    @pulumi.getter
    def sds(self) -> Sequence['outputs.GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationTrustSdResult']:
        """
        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 GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationTrustAcmResult(dict):
    def __init__(__self__, *,
                 certificate_authority_arns: Sequence[str]):
        """
        :param Sequence[str] certificate_authority_arns: One or more ACM ARNs.
        """
        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 ARNs.
        """
        return pulumi.get(self, "certificate_authority_arns")


@pulumi.output_type
class GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationTrustFileResult(dict):
    def __init__(__self__, *,
                 certificate_chain: str):
        """
        :param str certificate_chain: 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:
        """
        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 GetVirtualGatewaySpecBackendDefaultClientPolicyTlValidationTrustSdResult(dict):
    def __init__(__self__, *,
                 secret_name: str):
        """
        :param str secret_name: 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:
        """
        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 GetVirtualGatewaySpecListenerResult(dict):
    def __init__(__self__, *,
                 connection_pools: Sequence['outputs.GetVirtualGatewaySpecListenerConnectionPoolResult'],
                 health_checks: Sequence['outputs.GetVirtualGatewaySpecListenerHealthCheckResult'],
                 port_mappings: Sequence['outputs.GetVirtualGatewaySpecListenerPortMappingResult'],
                 tls: Sequence['outputs.GetVirtualGatewaySpecListenerTlResult']):
        """
        :param Sequence['GetVirtualGatewaySpecListenerConnectionPoolArgs'] connection_pools: Connection pool information for the listener.
        :param Sequence['GetVirtualGatewaySpecListenerHealthCheckArgs'] health_checks: Health check information for the listener.
        :param Sequence['GetVirtualGatewaySpecListenerPortMappingArgs'] port_mappings: Port mapping information for the listener.
        :param Sequence['GetVirtualGatewaySpecListenerTlArgs'] tls: Transport Layer Security (TLS) properties for the listener
        """
        pulumi.set(__self__, "connection_pools", connection_pools)
        pulumi.set(__self__, "health_checks", health_checks)
        pulumi.set(__self__, "port_mappings", port_mappings)
        pulumi.set(__self__, "tls", tls)

    @property
    @pulumi.getter(name="connectionPools")
    def connection_pools(self) -> Sequence['outputs.GetVirtualGatewaySpecListenerConnectionPoolResult']:
        """
        Connection pool information for the listener.
        """
        return pulumi.get(self, "connection_pools")

    @property
    @pulumi.getter(name="healthChecks")
    def health_checks(self) -> Sequence['outputs.GetVirtualGatewaySpecListenerHealthCheckResult']:
        """
        Health check information for the listener.
        """
        return pulumi.get(self, "health_checks")

    @property
    @pulumi.getter(name="portMappings")
    def port_mappings(self) -> Sequence['outputs.GetVirtualGatewaySpecListenerPortMappingResult']:
        """
        Port mapping information for the listener.
        """
        return pulumi.get(self, "port_mappings")

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


@pulumi.output_type
class GetVirtualGatewaySpecListenerConnectionPoolResult(dict):
    def __init__(__self__, *,
                 grpcs: Sequence['outputs.GetVirtualGatewaySpecListenerConnectionPoolGrpcResult'],
                 http2s: Sequence['outputs.GetVirtualGatewaySpecListenerConnectionPoolHttp2Result'],
                 https: Sequence['outputs.GetVirtualGatewaySpecListenerConnectionPoolHttpResult']):
        """
        :param Sequence['GetVirtualGatewaySpecListenerConnectionPoolGrpcArgs'] grpcs: Connection pool information for gRPC listeners.
        :param Sequence['GetVirtualGatewaySpecListenerConnectionPoolHttp2Args'] http2s: Connection pool information for HTTP2 listeners.
        :param Sequence['GetVirtualGatewaySpecListenerConnectionPoolHttpArgs'] https: Connection pool information for HTTP listeners.
        """
        pulumi.set(__self__, "grpcs", grpcs)
        pulumi.set(__self__, "http2s", http2s)
        pulumi.set(__self__, "https", https)

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

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

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


@pulumi.output_type
class GetVirtualGatewaySpecListenerConnectionPoolGrpcResult(dict):
    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 GetVirtualGatewaySpecListenerConnectionPoolHttp2Result(dict):
    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 GetVirtualGatewaySpecListenerConnectionPoolHttpResult(dict):
    def __init__(__self__, *,
                 max_connections: int,
                 max_pending_requests: 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`.
        :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)
        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) -> 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 GetVirtualGatewaySpecListenerHealthCheckResult(dict):
    def __init__(__self__, *,
                 healthy_threshold: int,
                 interval_millis: int,
                 path: str,
                 port: int,
                 protocol: str,
                 timeout_millis: int,
                 unhealthy_threshold: int):
        """
        :param int healthy_threshold: Number of consecutive successful health checks that must occur before declaring listener healthy.
        :param int interval_millis: Time period in milliseconds between each health check execution.
        :param str path: Destination path for the health check request. This is only required if the specified protocol is `http` or `http2`.
        :param int port: Destination port for the health check request. This port must match the port defined in the `port_mapping` for the listener.
        :param str protocol: Protocol for the health check request. Valid values are `http`, `http2`, and `grpc`.
        :param int timeout_millis: Amount of time to wait when receiving a response from the health check, in milliseconds.
        :param int unhealthy_threshold: Number of consecutive failed health checks that must occur before declaring a virtual gateway unhealthy.
        """
        pulumi.set(__self__, "healthy_threshold", healthy_threshold)
        pulumi.set(__self__, "interval_millis", interval_millis)
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "timeout_millis", timeout_millis)
        pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold)

    @property
    @pulumi.getter(name="healthyThreshold")
    def healthy_threshold(self) -> int:
        """
        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:
        """
        Time period in milliseconds between each health check execution.
        """
        return pulumi.get(self, "interval_millis")

    @property
    @pulumi.getter
    def path(self) -> str:
        """
        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) -> int:
        """
        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")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        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:
        """
        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:
        """
        Number of consecutive failed health checks that must occur before declaring a virtual gateway unhealthy.
        """
        return pulumi.get(self, "unhealthy_threshold")


@pulumi.output_type
class GetVirtualGatewaySpecListenerPortMappingResult(dict):
    def __init__(__self__, *,
                 port: int,
                 protocol: str):
        """
        :param int port: Destination port for the health check request. This port must match the port defined in the `port_mapping` for the listener.
        :param str protocol: Protocol for the health check request. Valid values are `http`, `http2`, and `grpc`.
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "protocol", protocol)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        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")

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


@pulumi.output_type
class GetVirtualGatewaySpecListenerTlResult(dict):
    def __init__(__self__, *,
                 certificates: Sequence['outputs.GetVirtualGatewaySpecListenerTlCertificateResult'],
                 mode: str,
                 validations: Sequence['outputs.GetVirtualGatewaySpecListenerTlValidationResult']):
        """
        :param Sequence['GetVirtualGatewaySpecListenerTlCertificateArgs'] certificates: Listener's TLS certificate.
        :param str mode: Listener's TLS mode. Valid values: `DISABLED`, `PERMISSIVE`, `STRICT`.
        :param Sequence['GetVirtualGatewaySpecListenerTlValidationArgs'] validations: Listener's Transport Layer Security (TLS) validation context.
        """
        pulumi.set(__self__, "certificates", certificates)
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "validations", validations)

    @property
    @pulumi.getter
    def certificates(self) -> Sequence['outputs.GetVirtualGatewaySpecListenerTlCertificateResult']:
        """
        Listener's TLS certificate.
        """
        return pulumi.get(self, "certificates")

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

    @property
    @pulumi.getter
    def validations(self) -> Sequence['outputs.GetVirtualGatewaySpecListenerTlValidationResult']:
        """
        Listener's Transport Layer Security (TLS) validation context.
        """
        return pulumi.get(self, "validations")


@pulumi.output_type
class GetVirtualGatewaySpecListenerTlCertificateResult(dict):
    def __init__(__self__, *,
                 acms: Sequence['outputs.GetVirtualGatewaySpecListenerTlCertificateAcmResult'],
                 files: Sequence['outputs.GetVirtualGatewaySpecListenerTlCertificateFileResult'],
                 sds: Sequence['outputs.GetVirtualGatewaySpecListenerTlCertificateSdResult']):
        """
        :param Sequence['GetVirtualGatewaySpecListenerTlCertificateAcmArgs'] acms: An AWS Certificate Manager (ACM) certificate.
        :param Sequence['GetVirtualGatewaySpecListenerTlCertificateFileArgs'] files: TLS validation context trust for a local file certificate.
        :param Sequence['GetVirtualGatewaySpecListenerTlCertificateSdArgs'] sds: TLS validation context trust for a [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        pulumi.set(__self__, "acms", acms)
        pulumi.set(__self__, "files", files)
        pulumi.set(__self__, "sds", sds)

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

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

    @property
    @pulumi.getter
    def sds(self) -> Sequence['outputs.GetVirtualGatewaySpecListenerTlCertificateSdResult']:
        """
        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 GetVirtualGatewaySpecListenerTlCertificateAcmResult(dict):
    def __init__(__self__, *,
                 certificate_arn: str):
        """
        :param str certificate_arn: ARN for the certificate.
        """
        pulumi.set(__self__, "certificate_arn", certificate_arn)

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


@pulumi.output_type
class GetVirtualGatewaySpecListenerTlCertificateFileResult(dict):
    def __init__(__self__, *,
                 certificate_chain: str,
                 private_key: str):
        """
        :param str certificate_chain: 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: 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:
        """
        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:
        """
        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 GetVirtualGatewaySpecListenerTlCertificateSdResult(dict):
    def __init__(__self__, *,
                 secret_name: str):
        """
        :param str secret_name: 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:
        """
        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 GetVirtualGatewaySpecListenerTlValidationResult(dict):
    def __init__(__self__, *,
                 subject_alternative_names: Sequence['outputs.GetVirtualGatewaySpecListenerTlValidationSubjectAlternativeNameResult'],
                 trusts: Sequence['outputs.GetVirtualGatewaySpecListenerTlValidationTrustResult']):
        """
        :param Sequence['GetVirtualGatewaySpecListenerTlValidationSubjectAlternativeNameArgs'] subject_alternative_names: SANs for a virtual gateway's listener's Transport Layer Security (TLS) validation context.
        :param Sequence['GetVirtualGatewaySpecListenerTlValidationTrustArgs'] trusts: TLS validation context trust.
        """
        pulumi.set(__self__, "subject_alternative_names", subject_alternative_names)
        pulumi.set(__self__, "trusts", trusts)

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

    @property
    @pulumi.getter
    def trusts(self) -> Sequence['outputs.GetVirtualGatewaySpecListenerTlValidationTrustResult']:
        """
        TLS validation context trust.
        """
        return pulumi.get(self, "trusts")


@pulumi.output_type
class GetVirtualGatewaySpecListenerTlValidationSubjectAlternativeNameResult(dict):
    def __init__(__self__, *,
                 matches: Sequence['outputs.GetVirtualGatewaySpecListenerTlValidationSubjectAlternativeNameMatchResult']):
        """
        :param Sequence['GetVirtualGatewaySpecListenerTlValidationSubjectAlternativeNameMatchArgs'] matches: Criteria for determining a SAN's match.
        """
        pulumi.set(__self__, "matches", matches)

    @property
    @pulumi.getter
    def matches(self) -> Sequence['outputs.GetVirtualGatewaySpecListenerTlValidationSubjectAlternativeNameMatchResult']:
        """
        Criteria for determining a SAN's match.
        """
        return pulumi.get(self, "matches")


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

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


@pulumi.output_type
class GetVirtualGatewaySpecListenerTlValidationTrustResult(dict):
    def __init__(__self__, *,
                 files: Sequence['outputs.GetVirtualGatewaySpecListenerTlValidationTrustFileResult'],
                 sds: Sequence['outputs.GetVirtualGatewaySpecListenerTlValidationTrustSdResult']):
        """
        :param Sequence['GetVirtualGatewaySpecListenerTlValidationTrustFileArgs'] files: TLS validation context trust for a local file certificate.
        :param Sequence['GetVirtualGatewaySpecListenerTlValidationTrustSdArgs'] sds: TLS validation context trust for a [Secret Discovery Service](https://www.envoyproxy.io/docs/envoy/latest/configuration/security/secret#secret-discovery-service-sds) certificate.
        """
        pulumi.set(__self__, "files", files)
        pulumi.set(__self__, "sds", sds)

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

    @property
    @pulumi.getter
    def sds(self) -> Sequence['outputs.GetVirtualGatewaySpecListenerTlValidationTrustSdResult']:
        """
        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 GetVirtualGatewaySpecListenerTlValidationTrustFileResult(dict):
    def __init__(__self__, *,
                 certificate_chain: str):
        """
        :param str certificate_chain: 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:
        """
        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 GetVirtualGatewaySpecListenerTlValidationTrustSdResult(dict):
    def __init__(__self__, *,
                 secret_name: str):
        """
        :param str secret_name: 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:
        """
        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 GetVirtualGatewaySpecLoggingResult(dict):
    def __init__(__self__, *,
                 access_logs: Sequence['outputs.GetVirtualGatewaySpecLoggingAccessLogResult']):
        """
        :param Sequence['GetVirtualGatewaySpecLoggingAccessLogArgs'] access_logs: Access log configuration for a virtual gateway.
        """
        pulumi.set(__self__, "access_logs", access_logs)

    @property
    @pulumi.getter(name="accessLogs")
    def access_logs(self) -> Sequence['outputs.GetVirtualGatewaySpecLoggingAccessLogResult']:
        """
        Access log configuration for a virtual gateway.
        """
        return pulumi.get(self, "access_logs")


@pulumi.output_type
class GetVirtualGatewaySpecLoggingAccessLogResult(dict):
    def __init__(__self__, *,
                 files: Sequence['outputs.GetVirtualGatewaySpecLoggingAccessLogFileResult']):
        """
        :param Sequence['GetVirtualGatewaySpecLoggingAccessLogFileArgs'] files: TLS validation context trust for a local file certificate.
        """
        pulumi.set(__self__, "files", files)

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


@pulumi.output_type
class GetVirtualGatewaySpecLoggingAccessLogFileResult(dict):
    def __init__(__self__, *,
                 formats: Sequence['outputs.GetVirtualGatewaySpecLoggingAccessLogFileFormatResult'],
                 path: str):
        """
        :param str path: Destination path for the health check request. This is only required if the specified protocol is `http` or `http2`.
        """
        pulumi.set(__self__, "formats", formats)
        pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def formats(self) -> Sequence['outputs.GetVirtualGatewaySpecLoggingAccessLogFileFormatResult']:
        return pulumi.get(self, "formats")

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


@pulumi.output_type
class GetVirtualGatewaySpecLoggingAccessLogFileFormatResult(dict):
    def __init__(__self__, *,
                 jsons: Sequence['outputs.GetVirtualGatewaySpecLoggingAccessLogFileFormatJsonResult'],
                 text: str):
        pulumi.set(__self__, "jsons", jsons)
        pulumi.set(__self__, "text", text)

    @property
    @pulumi.getter
    def jsons(self) -> Sequence['outputs.GetVirtualGatewaySpecLoggingAccessLogFileFormatJsonResult']:
        return pulumi.get(self, "jsons")

    @property
    @pulumi.getter
    def text(self) -> str:
        return pulumi.get(self, "text")


@pulumi.output_type
class GetVirtualGatewaySpecLoggingAccessLogFileFormatJsonResult(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

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


@pulumi.output_type
class GetVirtualServiceSpecResult(dict):
    def __init__(__self__, *,
                 providers: Sequence['outputs.GetVirtualServiceSpecProviderResult']):
        """
        :param Sequence['GetVirtualServiceSpecProviderArgs'] providers: 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']:
        """
        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: Virtual node associated with the virtual service.
        :param Sequence['GetVirtualServiceSpecProviderVirtualRouterArgs'] virtual_routers: 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']:
        """
        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']:
        """
        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: 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:
        """
        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: 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:
        """
        Name of the virtual router that is acting as a service provider.
        """
        return pulumi.get(self, "virtual_router_name")


