# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

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

__all__ = [
    'GatewayRouteGatewayRouteHostnameMatch',
    'GatewayRouteGatewayRouteHostnameRewrite',
    'GatewayRouteGatewayRouteMetadataMatch',
    'GatewayRouteGatewayRouteRangeMatch',
    'GatewayRouteGatewayRouteSpec',
    'GatewayRouteGatewayRouteTarget',
    'GatewayRouteGatewayRouteVirtualService',
    'GatewayRouteGrpcGatewayRoute',
    'GatewayRouteGrpcGatewayRouteAction',
    'GatewayRouteGrpcGatewayRouteMatch',
    'GatewayRouteGrpcGatewayRouteMetadata',
    'GatewayRouteGrpcGatewayRouteRewrite',
    'GatewayRouteHttpGatewayRoute',
    'GatewayRouteHttpGatewayRouteAction',
    'GatewayRouteHttpGatewayRouteHeader',
    'GatewayRouteHttpGatewayRouteHeaderMatch',
    'GatewayRouteHttpGatewayRouteMatch',
    'GatewayRouteHttpGatewayRoutePathRewrite',
    'GatewayRouteHttpGatewayRoutePrefixRewrite',
    'GatewayRouteHttpGatewayRouteRewrite',
    'GatewayRouteHttpPathMatch',
    'GatewayRouteHttpQueryParameterMatch',
    'GatewayRouteQueryParameter',
    'GatewayRouteTag',
    'MeshEgressFilter',
    'MeshMeshSpec',
    'MeshTag',
    'RouteDuration',
    'RouteGrpcRetryPolicy',
    'RouteGrpcRoute',
    'RouteGrpcRouteAction',
    'RouteGrpcRouteMatch',
    'RouteGrpcRouteMetadata',
    'RouteGrpcRouteMetadataMatchMethod',
    'RouteGrpcTimeout',
    'RouteHeaderMatchMethod',
    'RouteHttpPathMatch',
    'RouteHttpQueryParameterMatch',
    'RouteHttpRetryPolicy',
    'RouteHttpRoute',
    'RouteHttpRouteAction',
    'RouteHttpRouteHeader',
    'RouteHttpRouteMatch',
    'RouteHttpTimeout',
    'RouteMatchRange',
    'RouteQueryParameter',
    'RouteRouteSpec',
    'RouteTag',
    'RouteTcpRoute',
    'RouteTcpRouteAction',
    'RouteTcpTimeout',
    'RouteWeightedTarget',
    'VirtualGatewaySubjectAlternativeNameMatchers',
    'VirtualGatewaySubjectAlternativeNames',
    'VirtualGatewayTag',
    'VirtualGatewayVirtualGatewayAccessLog',
    'VirtualGatewayVirtualGatewayBackendDefaults',
    'VirtualGatewayVirtualGatewayClientPolicy',
    'VirtualGatewayVirtualGatewayClientPolicyTls',
    'VirtualGatewayVirtualGatewayClientTlsCertificate',
    'VirtualGatewayVirtualGatewayConnectionPool',
    'VirtualGatewayVirtualGatewayFileAccessLog',
    'VirtualGatewayVirtualGatewayGrpcConnectionPool',
    'VirtualGatewayVirtualGatewayHealthCheckPolicy',
    'VirtualGatewayVirtualGatewayHttp2ConnectionPool',
    'VirtualGatewayVirtualGatewayHttpConnectionPool',
    'VirtualGatewayVirtualGatewayListener',
    'VirtualGatewayVirtualGatewayListenerTls',
    'VirtualGatewayVirtualGatewayListenerTlsAcmCertificate',
    'VirtualGatewayVirtualGatewayListenerTlsCertificate',
    'VirtualGatewayVirtualGatewayListenerTlsFileCertificate',
    'VirtualGatewayVirtualGatewayListenerTlsSdsCertificate',
    'VirtualGatewayVirtualGatewayListenerTlsValidationContext',
    'VirtualGatewayVirtualGatewayListenerTlsValidationContextTrust',
    'VirtualGatewayVirtualGatewayLogging',
    'VirtualGatewayVirtualGatewayPortMapping',
    'VirtualGatewayVirtualGatewaySpec',
    'VirtualGatewayVirtualGatewayTlsValidationContext',
    'VirtualGatewayVirtualGatewayTlsValidationContextAcmTrust',
    'VirtualGatewayVirtualGatewayTlsValidationContextFileTrust',
    'VirtualGatewayVirtualGatewayTlsValidationContextSdsTrust',
    'VirtualGatewayVirtualGatewayTlsValidationContextTrust',
    'VirtualNodeAccessLog',
    'VirtualNodeAwsCloudMapInstanceAttribute',
    'VirtualNodeAwsCloudMapServiceDiscovery',
    'VirtualNodeBackend',
    'VirtualNodeBackendDefaults',
    'VirtualNodeClientPolicy',
    'VirtualNodeClientPolicyTls',
    'VirtualNodeClientTlsCertificate',
    'VirtualNodeDnsServiceDiscovery',
    'VirtualNodeDuration',
    'VirtualNodeFileAccessLog',
    'VirtualNodeGrpcTimeout',
    'VirtualNodeHealthCheck',
    'VirtualNodeHttpTimeout',
    'VirtualNodeListener',
    'VirtualNodeListenerTimeout',
    'VirtualNodeListenerTls',
    'VirtualNodeListenerTlsAcmCertificate',
    'VirtualNodeListenerTlsCertificate',
    'VirtualNodeListenerTlsFileCertificate',
    'VirtualNodeListenerTlsSdsCertificate',
    'VirtualNodeListenerTlsValidationContext',
    'VirtualNodeListenerTlsValidationContextTrust',
    'VirtualNodeLogging',
    'VirtualNodeOutlierDetection',
    'VirtualNodePortMapping',
    'VirtualNodeServiceDiscovery',
    'VirtualNodeSubjectAlternativeNameMatchers',
    'VirtualNodeSubjectAlternativeNames',
    'VirtualNodeTag',
    'VirtualNodeTcpTimeout',
    'VirtualNodeTlsValidationContext',
    'VirtualNodeTlsValidationContextAcmTrust',
    'VirtualNodeTlsValidationContextFileTrust',
    'VirtualNodeTlsValidationContextSdsTrust',
    'VirtualNodeTlsValidationContextTrust',
    'VirtualNodeVirtualNodeConnectionPool',
    'VirtualNodeVirtualNodeGrpcConnectionPool',
    'VirtualNodeVirtualNodeHttp2ConnectionPool',
    'VirtualNodeVirtualNodeHttpConnectionPool',
    'VirtualNodeVirtualNodeSpec',
    'VirtualNodeVirtualNodeTcpConnectionPool',
    'VirtualNodeVirtualServiceBackend',
    'VirtualRouterPortMapping',
    'VirtualRouterTag',
    'VirtualRouterVirtualRouterListener',
    'VirtualRouterVirtualRouterSpec',
    'VirtualServiceTag',
    'VirtualServiceVirtualNodeServiceProvider',
    'VirtualServiceVirtualRouterServiceProvider',
    'VirtualServiceVirtualServiceProvider',
    'VirtualServiceVirtualServiceSpec',
]

@pulumi.output_type
class GatewayRouteGatewayRouteHostnameMatch(dict):
    def __init__(__self__, *,
                 exact: Optional[str] = None,
                 suffix: Optional[str] = None):
        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]:
        return pulumi.get(self, "exact")

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


@pulumi.output_type
class GatewayRouteGatewayRouteHostnameRewrite(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 GatewayRouteGatewayRouteHostnameRewrite. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 default_target_hostname: Optional[str] = None):
        if default_target_hostname is not None:
            pulumi.set(__self__, "default_target_hostname", default_target_hostname)

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


@pulumi.output_type
class GatewayRouteGatewayRouteMetadataMatch(dict):
    def __init__(__self__, *,
                 exact: Optional[str] = None,
                 prefix: Optional[str] = None,
                 range: Optional['outputs.GatewayRouteGatewayRouteRangeMatch'] = None,
                 regex: Optional[str] = None,
                 suffix: Optional[str] = None):
        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]:
        return pulumi.get(self, "exact")

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

    @property
    @pulumi.getter
    def range(self) -> Optional['outputs.GatewayRouteGatewayRouteRangeMatch']:
        return pulumi.get(self, "range")

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

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


@pulumi.output_type
class GatewayRouteGatewayRouteRangeMatch(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 GatewayRouteGatewayRouteSpec(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 GatewayRouteGatewayRouteSpec. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 grpc_route: Optional['outputs.GatewayRouteGrpcGatewayRoute'] = None,
                 http2_route: Optional['outputs.GatewayRouteHttpGatewayRoute'] = None,
                 http_route: Optional['outputs.GatewayRouteHttpGatewayRoute'] = None):
        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.GatewayRouteGrpcGatewayRoute']:
        return pulumi.get(self, "grpc_route")

    @property
    @pulumi.getter(name="http2Route")
    def http2_route(self) -> Optional['outputs.GatewayRouteHttpGatewayRoute']:
        return pulumi.get(self, "http2_route")

    @property
    @pulumi.getter(name="httpRoute")
    def http_route(self) -> Optional['outputs.GatewayRouteHttpGatewayRoute']:
        return pulumi.get(self, "http_route")


@pulumi.output_type
class GatewayRouteGatewayRouteTarget(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 GatewayRouteGatewayRouteTarget. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 virtual_service: 'outputs.GatewayRouteGatewayRouteVirtualService'):
        pulumi.set(__self__, "virtual_service", virtual_service)

    @property
    @pulumi.getter(name="virtualService")
    def virtual_service(self) -> 'outputs.GatewayRouteGatewayRouteVirtualService':
        return pulumi.get(self, "virtual_service")


@pulumi.output_type
class GatewayRouteGatewayRouteVirtualService(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 GatewayRouteGatewayRouteVirtualService. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 virtual_service_name: str):
        pulumi.set(__self__, "virtual_service_name", virtual_service_name)

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


@pulumi.output_type
class GatewayRouteGrpcGatewayRoute(dict):
    def __init__(__self__, *,
                 action: 'outputs.GatewayRouteGrpcGatewayRouteAction',
                 match: 'outputs.GatewayRouteGrpcGatewayRouteMatch'):
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def action(self) -> 'outputs.GatewayRouteGrpcGatewayRouteAction':
        return pulumi.get(self, "action")

    @property
    @pulumi.getter
    def match(self) -> 'outputs.GatewayRouteGrpcGatewayRouteMatch':
        return pulumi.get(self, "match")


@pulumi.output_type
class GatewayRouteGrpcGatewayRouteAction(dict):
    def __init__(__self__, *,
                 target: 'outputs.GatewayRouteGatewayRouteTarget',
                 rewrite: Optional['outputs.GatewayRouteGrpcGatewayRouteRewrite'] = None):
        pulumi.set(__self__, "target", target)
        if rewrite is not None:
            pulumi.set(__self__, "rewrite", rewrite)

    @property
    @pulumi.getter
    def target(self) -> 'outputs.GatewayRouteGatewayRouteTarget':
        return pulumi.get(self, "target")

    @property
    @pulumi.getter
    def rewrite(self) -> Optional['outputs.GatewayRouteGrpcGatewayRouteRewrite']:
        return pulumi.get(self, "rewrite")


@pulumi.output_type
class GatewayRouteGrpcGatewayRouteMatch(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 GatewayRouteGrpcGatewayRouteMatch. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 hostname: Optional['outputs.GatewayRouteGatewayRouteHostnameMatch'] = None,
                 metadata: Optional[Sequence['outputs.GatewayRouteGrpcGatewayRouteMetadata']] = None,
                 service_name: Optional[str] = None):
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if metadata is not None:
            pulumi.set(__self__, "metadata", metadata)
        if service_name is not None:
            pulumi.set(__self__, "service_name", service_name)

    @property
    @pulumi.getter
    def hostname(self) -> Optional['outputs.GatewayRouteGatewayRouteHostnameMatch']:
        return pulumi.get(self, "hostname")

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

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


@pulumi.output_type
class GatewayRouteGrpcGatewayRouteMetadata(dict):
    def __init__(__self__, *,
                 name: str,
                 invert: Optional[bool] = None,
                 match: Optional['outputs.GatewayRouteGatewayRouteMetadataMatch'] = None):
        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:
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def match(self) -> Optional['outputs.GatewayRouteGatewayRouteMetadataMatch']:
        return pulumi.get(self, "match")


@pulumi.output_type
class GatewayRouteGrpcGatewayRouteRewrite(dict):
    def __init__(__self__, *,
                 hostname: Optional['outputs.GatewayRouteGatewayRouteHostnameRewrite'] = None):
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)

    @property
    @pulumi.getter
    def hostname(self) -> Optional['outputs.GatewayRouteGatewayRouteHostnameRewrite']:
        return pulumi.get(self, "hostname")


@pulumi.output_type
class GatewayRouteHttpGatewayRoute(dict):
    def __init__(__self__, *,
                 action: 'outputs.GatewayRouteHttpGatewayRouteAction',
                 match: 'outputs.GatewayRouteHttpGatewayRouteMatch'):
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def action(self) -> 'outputs.GatewayRouteHttpGatewayRouteAction':
        return pulumi.get(self, "action")

    @property
    @pulumi.getter
    def match(self) -> 'outputs.GatewayRouteHttpGatewayRouteMatch':
        return pulumi.get(self, "match")


@pulumi.output_type
class GatewayRouteHttpGatewayRouteAction(dict):
    def __init__(__self__, *,
                 target: 'outputs.GatewayRouteGatewayRouteTarget',
                 rewrite: Optional['outputs.GatewayRouteHttpGatewayRouteRewrite'] = None):
        pulumi.set(__self__, "target", target)
        if rewrite is not None:
            pulumi.set(__self__, "rewrite", rewrite)

    @property
    @pulumi.getter
    def target(self) -> 'outputs.GatewayRouteGatewayRouteTarget':
        return pulumi.get(self, "target")

    @property
    @pulumi.getter
    def rewrite(self) -> Optional['outputs.GatewayRouteHttpGatewayRouteRewrite']:
        return pulumi.get(self, "rewrite")


@pulumi.output_type
class GatewayRouteHttpGatewayRouteHeader(dict):
    def __init__(__self__, *,
                 name: str,
                 invert: Optional[bool] = None,
                 match: Optional['outputs.GatewayRouteHttpGatewayRouteHeaderMatch'] = None):
        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:
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def match(self) -> Optional['outputs.GatewayRouteHttpGatewayRouteHeaderMatch']:
        return pulumi.get(self, "match")


@pulumi.output_type
class GatewayRouteHttpGatewayRouteHeaderMatch(dict):
    def __init__(__self__, *,
                 exact: Optional[str] = None,
                 prefix: Optional[str] = None,
                 range: Optional['outputs.GatewayRouteGatewayRouteRangeMatch'] = None,
                 regex: Optional[str] = None,
                 suffix: Optional[str] = None):
        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]:
        return pulumi.get(self, "exact")

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

    @property
    @pulumi.getter
    def range(self) -> Optional['outputs.GatewayRouteGatewayRouteRangeMatch']:
        return pulumi.get(self, "range")

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

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


@pulumi.output_type
class GatewayRouteHttpGatewayRouteMatch(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "queryParameters":
            suggest = "query_parameters"

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

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

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

    def __init__(__self__, *,
                 headers: Optional[Sequence['outputs.GatewayRouteHttpGatewayRouteHeader']] = None,
                 hostname: Optional['outputs.GatewayRouteGatewayRouteHostnameMatch'] = None,
                 method: Optional[str] = None,
                 path: Optional['outputs.GatewayRouteHttpPathMatch'] = None,
                 prefix: Optional[str] = None,
                 query_parameters: Optional[Sequence['outputs.GatewayRouteQueryParameter']] = None):
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if method is not None:
            pulumi.set(__self__, "method", method)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)
        if query_parameters is not None:
            pulumi.set(__self__, "query_parameters", query_parameters)

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

    @property
    @pulumi.getter
    def hostname(self) -> Optional['outputs.GatewayRouteGatewayRouteHostnameMatch']:
        return pulumi.get(self, "hostname")

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

    @property
    @pulumi.getter
    def path(self) -> Optional['outputs.GatewayRouteHttpPathMatch']:
        return pulumi.get(self, "path")

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

    @property
    @pulumi.getter(name="queryParameters")
    def query_parameters(self) -> Optional[Sequence['outputs.GatewayRouteQueryParameter']]:
        return pulumi.get(self, "query_parameters")


@pulumi.output_type
class GatewayRouteHttpGatewayRoutePathRewrite(dict):
    def __init__(__self__, *,
                 exact: Optional[str] = None):
        if exact is not None:
            pulumi.set(__self__, "exact", exact)

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


@pulumi.output_type
class GatewayRouteHttpGatewayRoutePrefixRewrite(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 GatewayRouteHttpGatewayRoutePrefixRewrite. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 default_prefix: Optional[str] = None,
                 value: Optional[str] = None):
        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]:
        return pulumi.get(self, "default_prefix")

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


@pulumi.output_type
class GatewayRouteHttpGatewayRouteRewrite(dict):
    def __init__(__self__, *,
                 hostname: Optional['outputs.GatewayRouteGatewayRouteHostnameRewrite'] = None,
                 path: Optional['outputs.GatewayRouteHttpGatewayRoutePathRewrite'] = None,
                 prefix: Optional['outputs.GatewayRouteHttpGatewayRoutePrefixRewrite'] = None):
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)

    @property
    @pulumi.getter
    def hostname(self) -> Optional['outputs.GatewayRouteGatewayRouteHostnameRewrite']:
        return pulumi.get(self, "hostname")

    @property
    @pulumi.getter
    def path(self) -> Optional['outputs.GatewayRouteHttpGatewayRoutePathRewrite']:
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def prefix(self) -> Optional['outputs.GatewayRouteHttpGatewayRoutePrefixRewrite']:
        return pulumi.get(self, "prefix")


@pulumi.output_type
class GatewayRouteHttpPathMatch(dict):
    def __init__(__self__, *,
                 exact: Optional[str] = None,
                 regex: Optional[str] = None):
        if exact is not None:
            pulumi.set(__self__, "exact", exact)
        if regex is not None:
            pulumi.set(__self__, "regex", regex)

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

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


@pulumi.output_type
class GatewayRouteHttpQueryParameterMatch(dict):
    def __init__(__self__, *,
                 exact: Optional[str] = None):
        if exact is not None:
            pulumi.set(__self__, "exact", exact)

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


@pulumi.output_type
class GatewayRouteQueryParameter(dict):
    def __init__(__self__, *,
                 name: str,
                 match: Optional['outputs.GatewayRouteHttpQueryParameterMatch'] = None):
        pulumi.set(__self__, "name", name)
        if match is not None:
            pulumi.set(__self__, "match", match)

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

    @property
    @pulumi.getter
    def match(self) -> Optional['outputs.GatewayRouteHttpQueryParameterMatch']:
        return pulumi.get(self, "match")


@pulumi.output_type
class GatewayRouteTag(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 MeshEgressFilter(dict):
    def __init__(__self__, *,
                 type: str):
        pulumi.set(__self__, "type", type)

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


@pulumi.output_type
class MeshMeshSpec(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 MeshMeshSpec. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 egress_filter: Optional['outputs.MeshEgressFilter'] = None):
        if egress_filter is not None:
            pulumi.set(__self__, "egress_filter", egress_filter)

    @property
    @pulumi.getter(name="egressFilter")
    def egress_filter(self) -> Optional['outputs.MeshEgressFilter']:
        return pulumi.get(self, "egress_filter")


@pulumi.output_type
class MeshTag(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 RouteDuration(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 RouteGrpcRetryPolicy(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 RouteGrpcRetryPolicy. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 max_retries: int,
                 per_retry_timeout: 'outputs.RouteDuration',
                 grpc_retry_events: Optional[Sequence[str]] = None,
                 http_retry_events: Optional[Sequence[str]] = None,
                 tcp_retry_events: Optional[Sequence[str]] = None):
        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:
        return pulumi.get(self, "max_retries")

    @property
    @pulumi.getter(name="perRetryTimeout")
    def per_retry_timeout(self) -> 'outputs.RouteDuration':
        return pulumi.get(self, "per_retry_timeout")

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

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

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


@pulumi.output_type
class RouteGrpcRoute(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 RouteGrpcRoute. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 action: 'outputs.RouteGrpcRouteAction',
                 match: 'outputs.RouteGrpcRouteMatch',
                 retry_policy: Optional['outputs.RouteGrpcRetryPolicy'] = None,
                 timeout: Optional['outputs.RouteGrpcTimeout'] = None):
        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.RouteGrpcRouteAction':
        return pulumi.get(self, "action")

    @property
    @pulumi.getter
    def match(self) -> 'outputs.RouteGrpcRouteMatch':
        return pulumi.get(self, "match")

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

    @property
    @pulumi.getter
    def timeout(self) -> Optional['outputs.RouteGrpcTimeout']:
        return pulumi.get(self, "timeout")


@pulumi.output_type
class RouteGrpcRouteAction(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 RouteGrpcRouteAction. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 weighted_targets: Sequence['outputs.RouteWeightedTarget']):
        pulumi.set(__self__, "weighted_targets", weighted_targets)

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


@pulumi.output_type
class RouteGrpcRouteMatch(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 RouteGrpcRouteMatch. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 metadata: Optional[Sequence['outputs.RouteGrpcRouteMetadata']] = None,
                 method_name: Optional[str] = None,
                 service_name: Optional[str] = None):
        if metadata is not None:
            pulumi.set(__self__, "metadata", metadata)
        if method_name is not None:
            pulumi.set(__self__, "method_name", method_name)
        if service_name is not None:
            pulumi.set(__self__, "service_name", service_name)

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

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

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


@pulumi.output_type
class RouteGrpcRouteMetadata(dict):
    def __init__(__self__, *,
                 name: str,
                 invert: Optional[bool] = None,
                 match: Optional['outputs.RouteGrpcRouteMetadataMatchMethod'] = None):
        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:
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def match(self) -> Optional['outputs.RouteGrpcRouteMetadataMatchMethod']:
        return pulumi.get(self, "match")


@pulumi.output_type
class RouteGrpcRouteMetadataMatchMethod(dict):
    def __init__(__self__, *,
                 exact: Optional[str] = None,
                 prefix: Optional[str] = None,
                 range: Optional['outputs.RouteMatchRange'] = None,
                 regex: Optional[str] = None,
                 suffix: Optional[str] = None):
        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]:
        return pulumi.get(self, "exact")

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

    @property
    @pulumi.getter
    def range(self) -> Optional['outputs.RouteMatchRange']:
        return pulumi.get(self, "range")

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

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


@pulumi.output_type
class RouteGrpcTimeout(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 RouteGrpcTimeout. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 idle: Optional['outputs.RouteDuration'] = None,
                 per_request: Optional['outputs.RouteDuration'] = None):
        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.RouteDuration']:
        return pulumi.get(self, "idle")

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


@pulumi.output_type
class RouteHeaderMatchMethod(dict):
    def __init__(__self__, *,
                 exact: Optional[str] = None,
                 prefix: Optional[str] = None,
                 range: Optional['outputs.RouteMatchRange'] = None,
                 regex: Optional[str] = None,
                 suffix: Optional[str] = None):
        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]:
        return pulumi.get(self, "exact")

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

    @property
    @pulumi.getter
    def range(self) -> Optional['outputs.RouteMatchRange']:
        return pulumi.get(self, "range")

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

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


@pulumi.output_type
class RouteHttpPathMatch(dict):
    def __init__(__self__, *,
                 exact: Optional[str] = None,
                 regex: Optional[str] = None):
        if exact is not None:
            pulumi.set(__self__, "exact", exact)
        if regex is not None:
            pulumi.set(__self__, "regex", regex)

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

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


@pulumi.output_type
class RouteHttpQueryParameterMatch(dict):
    def __init__(__self__, *,
                 exact: Optional[str] = None):
        if exact is not None:
            pulumi.set(__self__, "exact", exact)

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


@pulumi.output_type
class RouteHttpRetryPolicy(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 RouteHttpRetryPolicy. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 max_retries: int,
                 per_retry_timeout: 'outputs.RouteDuration',
                 http_retry_events: Optional[Sequence[str]] = None,
                 tcp_retry_events: Optional[Sequence[str]] = None):
        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:
        return pulumi.get(self, "max_retries")

    @property
    @pulumi.getter(name="perRetryTimeout")
    def per_retry_timeout(self) -> 'outputs.RouteDuration':
        return pulumi.get(self, "per_retry_timeout")

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

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


@pulumi.output_type
class RouteHttpRoute(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 RouteHttpRoute. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 action: 'outputs.RouteHttpRouteAction',
                 match: 'outputs.RouteHttpRouteMatch',
                 retry_policy: Optional['outputs.RouteHttpRetryPolicy'] = None,
                 timeout: Optional['outputs.RouteHttpTimeout'] = None):
        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.RouteHttpRouteAction':
        return pulumi.get(self, "action")

    @property
    @pulumi.getter
    def match(self) -> 'outputs.RouteHttpRouteMatch':
        return pulumi.get(self, "match")

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

    @property
    @pulumi.getter
    def timeout(self) -> Optional['outputs.RouteHttpTimeout']:
        return pulumi.get(self, "timeout")


@pulumi.output_type
class RouteHttpRouteAction(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 RouteHttpRouteAction. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 weighted_targets: Sequence['outputs.RouteWeightedTarget']):
        pulumi.set(__self__, "weighted_targets", weighted_targets)

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


@pulumi.output_type
class RouteHttpRouteHeader(dict):
    def __init__(__self__, *,
                 name: str,
                 invert: Optional[bool] = None,
                 match: Optional['outputs.RouteHeaderMatchMethod'] = None):
        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:
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def match(self) -> Optional['outputs.RouteHeaderMatchMethod']:
        return pulumi.get(self, "match")


@pulumi.output_type
class RouteHttpRouteMatch(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "queryParameters":
            suggest = "query_parameters"

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

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

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

    def __init__(__self__, *,
                 headers: Optional[Sequence['outputs.RouteHttpRouteHeader']] = None,
                 method: Optional[str] = None,
                 path: Optional['outputs.RouteHttpPathMatch'] = None,
                 prefix: Optional[str] = None,
                 query_parameters: Optional[Sequence['outputs.RouteQueryParameter']] = None,
                 scheme: Optional[str] = None):
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if method is not None:
            pulumi.set(__self__, "method", method)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)
        if query_parameters is not None:
            pulumi.set(__self__, "query_parameters", query_parameters)
        if scheme is not None:
            pulumi.set(__self__, "scheme", scheme)

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

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

    @property
    @pulumi.getter
    def path(self) -> Optional['outputs.RouteHttpPathMatch']:
        return pulumi.get(self, "path")

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

    @property
    @pulumi.getter(name="queryParameters")
    def query_parameters(self) -> Optional[Sequence['outputs.RouteQueryParameter']]:
        return pulumi.get(self, "query_parameters")

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


@pulumi.output_type
class RouteHttpTimeout(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 RouteHttpTimeout. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 idle: Optional['outputs.RouteDuration'] = None,
                 per_request: Optional['outputs.RouteDuration'] = None):
        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.RouteDuration']:
        return pulumi.get(self, "idle")

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


@pulumi.output_type
class RouteMatchRange(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 RouteQueryParameter(dict):
    def __init__(__self__, *,
                 name: str,
                 match: Optional['outputs.RouteHttpQueryParameterMatch'] = None):
        pulumi.set(__self__, "name", name)
        if match is not None:
            pulumi.set(__self__, "match", match)

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

    @property
    @pulumi.getter
    def match(self) -> Optional['outputs.RouteHttpQueryParameterMatch']:
        return pulumi.get(self, "match")


@pulumi.output_type
class RouteRouteSpec(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 RouteRouteSpec. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 grpc_route: Optional['outputs.RouteGrpcRoute'] = None,
                 http2_route: Optional['outputs.RouteHttpRoute'] = None,
                 http_route: Optional['outputs.RouteHttpRoute'] = None,
                 priority: Optional[int] = None,
                 tcp_route: Optional['outputs.RouteTcpRoute'] = None):
        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.RouteGrpcRoute']:
        return pulumi.get(self, "grpc_route")

    @property
    @pulumi.getter(name="http2Route")
    def http2_route(self) -> Optional['outputs.RouteHttpRoute']:
        return pulumi.get(self, "http2_route")

    @property
    @pulumi.getter(name="httpRoute")
    def http_route(self) -> Optional['outputs.RouteHttpRoute']:
        return pulumi.get(self, "http_route")

    @property
    @pulumi.getter
    def priority(self) -> Optional[int]:
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter(name="tcpRoute")
    def tcp_route(self) -> Optional['outputs.RouteTcpRoute']:
        return pulumi.get(self, "tcp_route")


@pulumi.output_type
class RouteTag(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 RouteTcpRoute(dict):
    def __init__(__self__, *,
                 action: 'outputs.RouteTcpRouteAction',
                 timeout: Optional['outputs.RouteTcpTimeout'] = None):
        pulumi.set(__self__, "action", action)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter
    def action(self) -> 'outputs.RouteTcpRouteAction':
        return pulumi.get(self, "action")

    @property
    @pulumi.getter
    def timeout(self) -> Optional['outputs.RouteTcpTimeout']:
        return pulumi.get(self, "timeout")


@pulumi.output_type
class RouteTcpRouteAction(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 RouteTcpRouteAction. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 weighted_targets: Sequence['outputs.RouteWeightedTarget']):
        pulumi.set(__self__, "weighted_targets", weighted_targets)

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


@pulumi.output_type
class RouteTcpTimeout(dict):
    def __init__(__self__, *,
                 idle: Optional['outputs.RouteDuration'] = None):
        if idle is not None:
            pulumi.set(__self__, "idle", idle)

    @property
    @pulumi.getter
    def idle(self) -> Optional['outputs.RouteDuration']:
        return pulumi.get(self, "idle")


@pulumi.output_type
class RouteWeightedTarget(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 RouteWeightedTarget. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 virtual_node: str,
                 weight: int):
        pulumi.set(__self__, "virtual_node", virtual_node)
        pulumi.set(__self__, "weight", weight)

    @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 VirtualGatewaySubjectAlternativeNameMatchers(dict):
    def __init__(__self__, *,
                 exact: Optional[Sequence[str]] = None):
        if exact is not None:
            pulumi.set(__self__, "exact", exact)

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


@pulumi.output_type
class VirtualGatewaySubjectAlternativeNames(dict):
    def __init__(__self__, *,
                 match: 'outputs.VirtualGatewaySubjectAlternativeNameMatchers'):
        pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def match(self) -> 'outputs.VirtualGatewaySubjectAlternativeNameMatchers':
        return pulumi.get(self, "match")


@pulumi.output_type
class VirtualGatewayTag(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 VirtualGatewayVirtualGatewayAccessLog(dict):
    def __init__(__self__, *,
                 file: Optional['outputs.VirtualGatewayVirtualGatewayFileAccessLog'] = None):
        if file is not None:
            pulumi.set(__self__, "file", file)

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


@pulumi.output_type
class VirtualGatewayVirtualGatewayBackendDefaults(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 VirtualGatewayVirtualGatewayBackendDefaults. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 client_policy: Optional['outputs.VirtualGatewayVirtualGatewayClientPolicy'] = None):
        if client_policy is not None:
            pulumi.set(__self__, "client_policy", client_policy)

    @property
    @pulumi.getter(name="clientPolicy")
    def client_policy(self) -> Optional['outputs.VirtualGatewayVirtualGatewayClientPolicy']:
        return pulumi.get(self, "client_policy")


@pulumi.output_type
class VirtualGatewayVirtualGatewayClientPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "tLS":
            suggest = "t_ls"

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

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

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

    def __init__(__self__, *,
                 t_ls: Optional['outputs.VirtualGatewayVirtualGatewayClientPolicyTls'] = None):
        if t_ls is not None:
            pulumi.set(__self__, "t_ls", t_ls)

    @property
    @pulumi.getter(name="tLS")
    def t_ls(self) -> Optional['outputs.VirtualGatewayVirtualGatewayClientPolicyTls']:
        return pulumi.get(self, "t_ls")


@pulumi.output_type
class VirtualGatewayVirtualGatewayClientPolicyTls(dict):
    def __init__(__self__, *,
                 validation: 'outputs.VirtualGatewayVirtualGatewayTlsValidationContext',
                 certificate: Optional['outputs.VirtualGatewayVirtualGatewayClientTlsCertificate'] = None,
                 enforce: Optional[bool] = None,
                 ports: Optional[Sequence[int]] = None):
        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.VirtualGatewayVirtualGatewayTlsValidationContext':
        return pulumi.get(self, "validation")

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

    @property
    @pulumi.getter
    def enforce(self) -> Optional[bool]:
        return pulumi.get(self, "enforce")

    @property
    @pulumi.getter
    def ports(self) -> Optional[Sequence[int]]:
        return pulumi.get(self, "ports")


@pulumi.output_type
class VirtualGatewayVirtualGatewayClientTlsCertificate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sDS":
            suggest = "s_ds"

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

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

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

    def __init__(__self__, *,
                 file: Optional['outputs.VirtualGatewayVirtualGatewayListenerTlsFileCertificate'] = None,
                 s_ds: Optional['outputs.VirtualGatewayVirtualGatewayListenerTlsSdsCertificate'] = None):
        if file is not None:
            pulumi.set(__self__, "file", file)
        if s_ds is not None:
            pulumi.set(__self__, "s_ds", s_ds)

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

    @property
    @pulumi.getter(name="sDS")
    def s_ds(self) -> Optional['outputs.VirtualGatewayVirtualGatewayListenerTlsSdsCertificate']:
        return pulumi.get(self, "s_ds")


@pulumi.output_type
class VirtualGatewayVirtualGatewayConnectionPool(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "gRPC":
            suggest = "g_rpc"
        elif key == "hTTP":
            suggest = "h_ttp"
        elif key == "hTTP2":
            suggest = "h_ttp2"

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

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

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

    def __init__(__self__, *,
                 g_rpc: Optional['outputs.VirtualGatewayVirtualGatewayGrpcConnectionPool'] = None,
                 h_ttp: Optional['outputs.VirtualGatewayVirtualGatewayHttpConnectionPool'] = None,
                 h_ttp2: Optional['outputs.VirtualGatewayVirtualGatewayHttp2ConnectionPool'] = None):
        if g_rpc is not None:
            pulumi.set(__self__, "g_rpc", g_rpc)
        if h_ttp is not None:
            pulumi.set(__self__, "h_ttp", h_ttp)
        if h_ttp2 is not None:
            pulumi.set(__self__, "h_ttp2", h_ttp2)

    @property
    @pulumi.getter(name="gRPC")
    def g_rpc(self) -> Optional['outputs.VirtualGatewayVirtualGatewayGrpcConnectionPool']:
        return pulumi.get(self, "g_rpc")

    @property
    @pulumi.getter(name="hTTP")
    def h_ttp(self) -> Optional['outputs.VirtualGatewayVirtualGatewayHttpConnectionPool']:
        return pulumi.get(self, "h_ttp")

    @property
    @pulumi.getter(name="hTTP2")
    def h_ttp2(self) -> Optional['outputs.VirtualGatewayVirtualGatewayHttp2ConnectionPool']:
        return pulumi.get(self, "h_ttp2")


@pulumi.output_type
class VirtualGatewayVirtualGatewayFileAccessLog(dict):
    def __init__(__self__, *,
                 path: str):
        pulumi.set(__self__, "path", path)

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


@pulumi.output_type
class VirtualGatewayVirtualGatewayGrpcConnectionPool(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 VirtualGatewayVirtualGatewayGrpcConnectionPool. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 max_requests: int):
        pulumi.set(__self__, "max_requests", max_requests)

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


@pulumi.output_type
class VirtualGatewayVirtualGatewayHealthCheckPolicy(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 VirtualGatewayVirtualGatewayHealthCheckPolicy. Access the value via the '{suggest}' property getter instead.")

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

    def get(self, key: str, default = None) -> Any:
        VirtualGatewayVirtualGatewayHealthCheckPolicy.__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):
        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:
        return pulumi.get(self, "healthy_threshold")

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

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

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

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

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        return pulumi.get(self, "path")

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


@pulumi.output_type
class VirtualGatewayVirtualGatewayHttp2ConnectionPool(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 VirtualGatewayVirtualGatewayHttp2ConnectionPool. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 max_requests: int):
        pulumi.set(__self__, "max_requests", max_requests)

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


@pulumi.output_type
class VirtualGatewayVirtualGatewayHttpConnectionPool(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 VirtualGatewayVirtualGatewayHttpConnectionPool. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 max_connections: int,
                 max_pending_requests: Optional[int] = None):
        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:
        return pulumi.get(self, "max_connections")

    @property
    @pulumi.getter(name="maxPendingRequests")
    def max_pending_requests(self) -> Optional[int]:
        return pulumi.get(self, "max_pending_requests")


@pulumi.output_type
class VirtualGatewayVirtualGatewayListener(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 == "tLS":
            suggest = "t_ls"

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

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

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

    def __init__(__self__, *,
                 port_mapping: 'outputs.VirtualGatewayVirtualGatewayPortMapping',
                 connection_pool: Optional['outputs.VirtualGatewayVirtualGatewayConnectionPool'] = None,
                 health_check: Optional['outputs.VirtualGatewayVirtualGatewayHealthCheckPolicy'] = None,
                 t_ls: Optional['outputs.VirtualGatewayVirtualGatewayListenerTls'] = None):
        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 t_ls is not None:
            pulumi.set(__self__, "t_ls", t_ls)

    @property
    @pulumi.getter(name="portMapping")
    def port_mapping(self) -> 'outputs.VirtualGatewayVirtualGatewayPortMapping':
        return pulumi.get(self, "port_mapping")

    @property
    @pulumi.getter(name="connectionPool")
    def connection_pool(self) -> Optional['outputs.VirtualGatewayVirtualGatewayConnectionPool']:
        return pulumi.get(self, "connection_pool")

    @property
    @pulumi.getter(name="healthCheck")
    def health_check(self) -> Optional['outputs.VirtualGatewayVirtualGatewayHealthCheckPolicy']:
        return pulumi.get(self, "health_check")

    @property
    @pulumi.getter(name="tLS")
    def t_ls(self) -> Optional['outputs.VirtualGatewayVirtualGatewayListenerTls']:
        return pulumi.get(self, "t_ls")


@pulumi.output_type
class VirtualGatewayVirtualGatewayListenerTls(dict):
    def __init__(__self__, *,
                 certificate: 'outputs.VirtualGatewayVirtualGatewayListenerTlsCertificate',
                 mode: str,
                 validation: Optional['outputs.VirtualGatewayVirtualGatewayListenerTlsValidationContext'] = None):
        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.VirtualGatewayVirtualGatewayListenerTlsCertificate':
        return pulumi.get(self, "certificate")

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

    @property
    @pulumi.getter
    def validation(self) -> Optional['outputs.VirtualGatewayVirtualGatewayListenerTlsValidationContext']:
        return pulumi.get(self, "validation")


@pulumi.output_type
class VirtualGatewayVirtualGatewayListenerTlsAcmCertificate(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 VirtualGatewayVirtualGatewayListenerTlsAcmCertificate. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 certificate_arn: str):
        pulumi.set(__self__, "certificate_arn", certificate_arn)

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


@pulumi.output_type
class VirtualGatewayVirtualGatewayListenerTlsCertificate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aCM":
            suggest = "a_cm"
        elif key == "sDS":
            suggest = "s_ds"

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

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

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

    def __init__(__self__, *,
                 a_cm: Optional['outputs.VirtualGatewayVirtualGatewayListenerTlsAcmCertificate'] = None,
                 file: Optional['outputs.VirtualGatewayVirtualGatewayListenerTlsFileCertificate'] = None,
                 s_ds: Optional['outputs.VirtualGatewayVirtualGatewayListenerTlsSdsCertificate'] = None):
        if a_cm is not None:
            pulumi.set(__self__, "a_cm", a_cm)
        if file is not None:
            pulumi.set(__self__, "file", file)
        if s_ds is not None:
            pulumi.set(__self__, "s_ds", s_ds)

    @property
    @pulumi.getter(name="aCM")
    def a_cm(self) -> Optional['outputs.VirtualGatewayVirtualGatewayListenerTlsAcmCertificate']:
        return pulumi.get(self, "a_cm")

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

    @property
    @pulumi.getter(name="sDS")
    def s_ds(self) -> Optional['outputs.VirtualGatewayVirtualGatewayListenerTlsSdsCertificate']:
        return pulumi.get(self, "s_ds")


@pulumi.output_type
class VirtualGatewayVirtualGatewayListenerTlsFileCertificate(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 VirtualGatewayVirtualGatewayListenerTlsFileCertificate. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 certificate_chain: str,
                 private_key: str):
        pulumi.set(__self__, "certificate_chain", certificate_chain)
        pulumi.set(__self__, "private_key", private_key)

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

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


@pulumi.output_type
class VirtualGatewayVirtualGatewayListenerTlsSdsCertificate(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 VirtualGatewayVirtualGatewayListenerTlsSdsCertificate. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 secret_name: str):
        pulumi.set(__self__, "secret_name", secret_name)

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


@pulumi.output_type
class VirtualGatewayVirtualGatewayListenerTlsValidationContext(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 VirtualGatewayVirtualGatewayListenerTlsValidationContext. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 trust: 'outputs.VirtualGatewayVirtualGatewayListenerTlsValidationContextTrust',
                 subject_alternative_names: Optional['outputs.VirtualGatewaySubjectAlternativeNames'] = None):
        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.VirtualGatewayVirtualGatewayListenerTlsValidationContextTrust':
        return pulumi.get(self, "trust")

    @property
    @pulumi.getter(name="subjectAlternativeNames")
    def subject_alternative_names(self) -> Optional['outputs.VirtualGatewaySubjectAlternativeNames']:
        return pulumi.get(self, "subject_alternative_names")


@pulumi.output_type
class VirtualGatewayVirtualGatewayListenerTlsValidationContextTrust(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sDS":
            suggest = "s_ds"

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

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

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

    def __init__(__self__, *,
                 file: Optional['outputs.VirtualGatewayVirtualGatewayTlsValidationContextFileTrust'] = None,
                 s_ds: Optional['outputs.VirtualGatewayVirtualGatewayTlsValidationContextSdsTrust'] = None):
        if file is not None:
            pulumi.set(__self__, "file", file)
        if s_ds is not None:
            pulumi.set(__self__, "s_ds", s_ds)

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

    @property
    @pulumi.getter(name="sDS")
    def s_ds(self) -> Optional['outputs.VirtualGatewayVirtualGatewayTlsValidationContextSdsTrust']:
        return pulumi.get(self, "s_ds")


@pulumi.output_type
class VirtualGatewayVirtualGatewayLogging(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 VirtualGatewayVirtualGatewayLogging. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 access_log: Optional['outputs.VirtualGatewayVirtualGatewayAccessLog'] = None):
        if access_log is not None:
            pulumi.set(__self__, "access_log", access_log)

    @property
    @pulumi.getter(name="accessLog")
    def access_log(self) -> Optional['outputs.VirtualGatewayVirtualGatewayAccessLog']:
        return pulumi.get(self, "access_log")


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

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

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


@pulumi.output_type
class VirtualGatewayVirtualGatewaySpec(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 VirtualGatewayVirtualGatewaySpec. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 listeners: Sequence['outputs.VirtualGatewayVirtualGatewayListener'],
                 backend_defaults: Optional['outputs.VirtualGatewayVirtualGatewayBackendDefaults'] = None,
                 logging: Optional['outputs.VirtualGatewayVirtualGatewayLogging'] = None):
        pulumi.set(__self__, "listeners", listeners)
        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 listeners(self) -> Sequence['outputs.VirtualGatewayVirtualGatewayListener']:
        return pulumi.get(self, "listeners")

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

    @property
    @pulumi.getter
    def logging(self) -> Optional['outputs.VirtualGatewayVirtualGatewayLogging']:
        return pulumi.get(self, "logging")


@pulumi.output_type
class VirtualGatewayVirtualGatewayTlsValidationContext(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 VirtualGatewayVirtualGatewayTlsValidationContext. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 trust: 'outputs.VirtualGatewayVirtualGatewayTlsValidationContextTrust',
                 subject_alternative_names: Optional['outputs.VirtualGatewaySubjectAlternativeNames'] = None):
        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.VirtualGatewayVirtualGatewayTlsValidationContextTrust':
        return pulumi.get(self, "trust")

    @property
    @pulumi.getter(name="subjectAlternativeNames")
    def subject_alternative_names(self) -> Optional['outputs.VirtualGatewaySubjectAlternativeNames']:
        return pulumi.get(self, "subject_alternative_names")


@pulumi.output_type
class VirtualGatewayVirtualGatewayTlsValidationContextAcmTrust(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 VirtualGatewayVirtualGatewayTlsValidationContextAcmTrust. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 certificate_authority_arns: Sequence[str]):
        pulumi.set(__self__, "certificate_authority_arns", certificate_authority_arns)

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


@pulumi.output_type
class VirtualGatewayVirtualGatewayTlsValidationContextFileTrust(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 VirtualGatewayVirtualGatewayTlsValidationContextFileTrust. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 certificate_chain: str):
        pulumi.set(__self__, "certificate_chain", certificate_chain)

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


@pulumi.output_type
class VirtualGatewayVirtualGatewayTlsValidationContextSdsTrust(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 VirtualGatewayVirtualGatewayTlsValidationContextSdsTrust. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 secret_name: str):
        pulumi.set(__self__, "secret_name", secret_name)

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


@pulumi.output_type
class VirtualGatewayVirtualGatewayTlsValidationContextTrust(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aCM":
            suggest = "a_cm"
        elif key == "sDS":
            suggest = "s_ds"

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

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

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

    def __init__(__self__, *,
                 a_cm: Optional['outputs.VirtualGatewayVirtualGatewayTlsValidationContextAcmTrust'] = None,
                 file: Optional['outputs.VirtualGatewayVirtualGatewayTlsValidationContextFileTrust'] = None,
                 s_ds: Optional['outputs.VirtualGatewayVirtualGatewayTlsValidationContextSdsTrust'] = None):
        if a_cm is not None:
            pulumi.set(__self__, "a_cm", a_cm)
        if file is not None:
            pulumi.set(__self__, "file", file)
        if s_ds is not None:
            pulumi.set(__self__, "s_ds", s_ds)

    @property
    @pulumi.getter(name="aCM")
    def a_cm(self) -> Optional['outputs.VirtualGatewayVirtualGatewayTlsValidationContextAcmTrust']:
        return pulumi.get(self, "a_cm")

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

    @property
    @pulumi.getter(name="sDS")
    def s_ds(self) -> Optional['outputs.VirtualGatewayVirtualGatewayTlsValidationContextSdsTrust']:
        return pulumi.get(self, "s_ds")


@pulumi.output_type
class VirtualNodeAccessLog(dict):
    def __init__(__self__, *,
                 file: Optional['outputs.VirtualNodeFileAccessLog'] = None):
        if file is not None:
            pulumi.set(__self__, "file", file)

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


@pulumi.output_type
class VirtualNodeAwsCloudMapInstanceAttribute(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 VirtualNodeAwsCloudMapServiceDiscovery(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 VirtualNodeAwsCloudMapServiceDiscovery. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 namespace_name: str,
                 service_name: str,
                 attributes: Optional[Sequence['outputs.VirtualNodeAwsCloudMapInstanceAttribute']] = None):
        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:
        return pulumi.get(self, "namespace_name")

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

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


@pulumi.output_type
class VirtualNodeBackend(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 VirtualNodeBackend. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 virtual_service: Optional['outputs.VirtualNodeVirtualServiceBackend'] = None):
        if virtual_service is not None:
            pulumi.set(__self__, "virtual_service", virtual_service)

    @property
    @pulumi.getter(name="virtualService")
    def virtual_service(self) -> Optional['outputs.VirtualNodeVirtualServiceBackend']:
        return pulumi.get(self, "virtual_service")


@pulumi.output_type
class VirtualNodeBackendDefaults(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 VirtualNodeBackendDefaults. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 client_policy: Optional['outputs.VirtualNodeClientPolicy'] = None):
        if client_policy is not None:
            pulumi.set(__self__, "client_policy", client_policy)

    @property
    @pulumi.getter(name="clientPolicy")
    def client_policy(self) -> Optional['outputs.VirtualNodeClientPolicy']:
        return pulumi.get(self, "client_policy")


@pulumi.output_type
class VirtualNodeClientPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "tLS":
            suggest = "t_ls"

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

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

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

    def __init__(__self__, *,
                 t_ls: Optional['outputs.VirtualNodeClientPolicyTls'] = None):
        if t_ls is not None:
            pulumi.set(__self__, "t_ls", t_ls)

    @property
    @pulumi.getter(name="tLS")
    def t_ls(self) -> Optional['outputs.VirtualNodeClientPolicyTls']:
        return pulumi.get(self, "t_ls")


@pulumi.output_type
class VirtualNodeClientPolicyTls(dict):
    def __init__(__self__, *,
                 validation: 'outputs.VirtualNodeTlsValidationContext',
                 certificate: Optional['outputs.VirtualNodeClientTlsCertificate'] = None,
                 enforce: Optional[bool] = None,
                 ports: Optional[Sequence[int]] = None):
        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.VirtualNodeTlsValidationContext':
        return pulumi.get(self, "validation")

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

    @property
    @pulumi.getter
    def enforce(self) -> Optional[bool]:
        return pulumi.get(self, "enforce")

    @property
    @pulumi.getter
    def ports(self) -> Optional[Sequence[int]]:
        return pulumi.get(self, "ports")


@pulumi.output_type
class VirtualNodeClientTlsCertificate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sDS":
            suggest = "s_ds"

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

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

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

    def __init__(__self__, *,
                 file: Optional['outputs.VirtualNodeListenerTlsFileCertificate'] = None,
                 s_ds: Optional['outputs.VirtualNodeListenerTlsSdsCertificate'] = None):
        if file is not None:
            pulumi.set(__self__, "file", file)
        if s_ds is not None:
            pulumi.set(__self__, "s_ds", s_ds)

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

    @property
    @pulumi.getter(name="sDS")
    def s_ds(self) -> Optional['outputs.VirtualNodeListenerTlsSdsCertificate']:
        return pulumi.get(self, "s_ds")


@pulumi.output_type
class VirtualNodeDnsServiceDiscovery(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "responseType":
            suggest = "response_type"

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

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

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

    def __init__(__self__, *,
                 hostname: str,
                 response_type: Optional[str] = None):
        pulumi.set(__self__, "hostname", hostname)
        if response_type is not None:
            pulumi.set(__self__, "response_type", response_type)

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

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


@pulumi.output_type
class VirtualNodeDuration(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 VirtualNodeFileAccessLog(dict):
    def __init__(__self__, *,
                 path: str):
        pulumi.set(__self__, "path", path)

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


@pulumi.output_type
class VirtualNodeGrpcTimeout(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 VirtualNodeGrpcTimeout. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 idle: Optional['outputs.VirtualNodeDuration'] = None,
                 per_request: Optional['outputs.VirtualNodeDuration'] = None):
        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.VirtualNodeDuration']:
        return pulumi.get(self, "idle")

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


@pulumi.output_type
class VirtualNodeHealthCheck(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 VirtualNodeHealthCheck. Access the value via the '{suggest}' property getter instead.")

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

    def get(self, key: str, default = None) -> Any:
        VirtualNodeHealthCheck.__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):
        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:
        return pulumi.get(self, "healthy_threshold")

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

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

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

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

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        return pulumi.get(self, "path")

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


@pulumi.output_type
class VirtualNodeHttpTimeout(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 VirtualNodeHttpTimeout. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 idle: Optional['outputs.VirtualNodeDuration'] = None,
                 per_request: Optional['outputs.VirtualNodeDuration'] = None):
        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.VirtualNodeDuration']:
        return pulumi.get(self, "idle")

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


@pulumi.output_type
class VirtualNodeListener(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"
        elif key == "tLS":
            suggest = "t_ls"

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

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

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

    def __init__(__self__, *,
                 port_mapping: 'outputs.VirtualNodePortMapping',
                 connection_pool: Optional['outputs.VirtualNodeVirtualNodeConnectionPool'] = None,
                 health_check: Optional['outputs.VirtualNodeHealthCheck'] = None,
                 outlier_detection: Optional['outputs.VirtualNodeOutlierDetection'] = None,
                 t_ls: Optional['outputs.VirtualNodeListenerTls'] = None,
                 timeout: Optional['outputs.VirtualNodeListenerTimeout'] = None):
        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 t_ls is not None:
            pulumi.set(__self__, "t_ls", t_ls)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter(name="portMapping")
    def port_mapping(self) -> 'outputs.VirtualNodePortMapping':
        return pulumi.get(self, "port_mapping")

    @property
    @pulumi.getter(name="connectionPool")
    def connection_pool(self) -> Optional['outputs.VirtualNodeVirtualNodeConnectionPool']:
        return pulumi.get(self, "connection_pool")

    @property
    @pulumi.getter(name="healthCheck")
    def health_check(self) -> Optional['outputs.VirtualNodeHealthCheck']:
        return pulumi.get(self, "health_check")

    @property
    @pulumi.getter(name="outlierDetection")
    def outlier_detection(self) -> Optional['outputs.VirtualNodeOutlierDetection']:
        return pulumi.get(self, "outlier_detection")

    @property
    @pulumi.getter(name="tLS")
    def t_ls(self) -> Optional['outputs.VirtualNodeListenerTls']:
        return pulumi.get(self, "t_ls")

    @property
    @pulumi.getter
    def timeout(self) -> Optional['outputs.VirtualNodeListenerTimeout']:
        return pulumi.get(self, "timeout")


@pulumi.output_type
class VirtualNodeListenerTimeout(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "gRPC":
            suggest = "g_rpc"
        elif key == "hTTP":
            suggest = "h_ttp"
        elif key == "hTTP2":
            suggest = "h_ttp2"
        elif key == "tCP":
            suggest = "t_cp"

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

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

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

    def __init__(__self__, *,
                 g_rpc: Optional['outputs.VirtualNodeGrpcTimeout'] = None,
                 h_ttp: Optional['outputs.VirtualNodeHttpTimeout'] = None,
                 h_ttp2: Optional['outputs.VirtualNodeHttpTimeout'] = None,
                 t_cp: Optional['outputs.VirtualNodeTcpTimeout'] = None):
        if g_rpc is not None:
            pulumi.set(__self__, "g_rpc", g_rpc)
        if h_ttp is not None:
            pulumi.set(__self__, "h_ttp", h_ttp)
        if h_ttp2 is not None:
            pulumi.set(__self__, "h_ttp2", h_ttp2)
        if t_cp is not None:
            pulumi.set(__self__, "t_cp", t_cp)

    @property
    @pulumi.getter(name="gRPC")
    def g_rpc(self) -> Optional['outputs.VirtualNodeGrpcTimeout']:
        return pulumi.get(self, "g_rpc")

    @property
    @pulumi.getter(name="hTTP")
    def h_ttp(self) -> Optional['outputs.VirtualNodeHttpTimeout']:
        return pulumi.get(self, "h_ttp")

    @property
    @pulumi.getter(name="hTTP2")
    def h_ttp2(self) -> Optional['outputs.VirtualNodeHttpTimeout']:
        return pulumi.get(self, "h_ttp2")

    @property
    @pulumi.getter(name="tCP")
    def t_cp(self) -> Optional['outputs.VirtualNodeTcpTimeout']:
        return pulumi.get(self, "t_cp")


@pulumi.output_type
class VirtualNodeListenerTls(dict):
    def __init__(__self__, *,
                 certificate: 'outputs.VirtualNodeListenerTlsCertificate',
                 mode: str,
                 validation: Optional['outputs.VirtualNodeListenerTlsValidationContext'] = None):
        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.VirtualNodeListenerTlsCertificate':
        return pulumi.get(self, "certificate")

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

    @property
    @pulumi.getter
    def validation(self) -> Optional['outputs.VirtualNodeListenerTlsValidationContext']:
        return pulumi.get(self, "validation")


@pulumi.output_type
class VirtualNodeListenerTlsAcmCertificate(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 VirtualNodeListenerTlsAcmCertificate. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 certificate_arn: str):
        pulumi.set(__self__, "certificate_arn", certificate_arn)

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


@pulumi.output_type
class VirtualNodeListenerTlsCertificate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aCM":
            suggest = "a_cm"
        elif key == "sDS":
            suggest = "s_ds"

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

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

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

    def __init__(__self__, *,
                 a_cm: Optional['outputs.VirtualNodeListenerTlsAcmCertificate'] = None,
                 file: Optional['outputs.VirtualNodeListenerTlsFileCertificate'] = None,
                 s_ds: Optional['outputs.VirtualNodeListenerTlsSdsCertificate'] = None):
        if a_cm is not None:
            pulumi.set(__self__, "a_cm", a_cm)
        if file is not None:
            pulumi.set(__self__, "file", file)
        if s_ds is not None:
            pulumi.set(__self__, "s_ds", s_ds)

    @property
    @pulumi.getter(name="aCM")
    def a_cm(self) -> Optional['outputs.VirtualNodeListenerTlsAcmCertificate']:
        return pulumi.get(self, "a_cm")

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

    @property
    @pulumi.getter(name="sDS")
    def s_ds(self) -> Optional['outputs.VirtualNodeListenerTlsSdsCertificate']:
        return pulumi.get(self, "s_ds")


@pulumi.output_type
class VirtualNodeListenerTlsFileCertificate(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 VirtualNodeListenerTlsFileCertificate. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 certificate_chain: str,
                 private_key: str):
        pulumi.set(__self__, "certificate_chain", certificate_chain)
        pulumi.set(__self__, "private_key", private_key)

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

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


@pulumi.output_type
class VirtualNodeListenerTlsSdsCertificate(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 VirtualNodeListenerTlsSdsCertificate. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 secret_name: str):
        pulumi.set(__self__, "secret_name", secret_name)

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


@pulumi.output_type
class VirtualNodeListenerTlsValidationContext(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 VirtualNodeListenerTlsValidationContext. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 trust: 'outputs.VirtualNodeListenerTlsValidationContextTrust',
                 subject_alternative_names: Optional['outputs.VirtualNodeSubjectAlternativeNames'] = None):
        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.VirtualNodeListenerTlsValidationContextTrust':
        return pulumi.get(self, "trust")

    @property
    @pulumi.getter(name="subjectAlternativeNames")
    def subject_alternative_names(self) -> Optional['outputs.VirtualNodeSubjectAlternativeNames']:
        return pulumi.get(self, "subject_alternative_names")


@pulumi.output_type
class VirtualNodeListenerTlsValidationContextTrust(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sDS":
            suggest = "s_ds"

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

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

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

    def __init__(__self__, *,
                 file: Optional['outputs.VirtualNodeTlsValidationContextFileTrust'] = None,
                 s_ds: Optional['outputs.VirtualNodeTlsValidationContextSdsTrust'] = None):
        if file is not None:
            pulumi.set(__self__, "file", file)
        if s_ds is not None:
            pulumi.set(__self__, "s_ds", s_ds)

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

    @property
    @pulumi.getter(name="sDS")
    def s_ds(self) -> Optional['outputs.VirtualNodeTlsValidationContextSdsTrust']:
        return pulumi.get(self, "s_ds")


@pulumi.output_type
class VirtualNodeLogging(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 VirtualNodeLogging. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 access_log: Optional['outputs.VirtualNodeAccessLog'] = None):
        if access_log is not None:
            pulumi.set(__self__, "access_log", access_log)

    @property
    @pulumi.getter(name="accessLog")
    def access_log(self) -> Optional['outputs.VirtualNodeAccessLog']:
        return pulumi.get(self, "access_log")


@pulumi.output_type
class VirtualNodeOutlierDetection(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 VirtualNodeOutlierDetection. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 base_ejection_duration: 'outputs.VirtualNodeDuration',
                 interval: 'outputs.VirtualNodeDuration',
                 max_ejection_percent: int,
                 max_server_errors: int):
        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.VirtualNodeDuration':
        return pulumi.get(self, "base_ejection_duration")

    @property
    @pulumi.getter
    def interval(self) -> 'outputs.VirtualNodeDuration':
        return pulumi.get(self, "interval")

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

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


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

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

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


@pulumi.output_type
class VirtualNodeServiceDiscovery(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aWSCloudMap":
            suggest = "a_ws_cloud_map"
        elif key == "dNS":
            suggest = "d_ns"

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

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

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

    def __init__(__self__, *,
                 a_ws_cloud_map: Optional['outputs.VirtualNodeAwsCloudMapServiceDiscovery'] = None,
                 d_ns: Optional['outputs.VirtualNodeDnsServiceDiscovery'] = None):
        if a_ws_cloud_map is not None:
            pulumi.set(__self__, "a_ws_cloud_map", a_ws_cloud_map)
        if d_ns is not None:
            pulumi.set(__self__, "d_ns", d_ns)

    @property
    @pulumi.getter(name="aWSCloudMap")
    def a_ws_cloud_map(self) -> Optional['outputs.VirtualNodeAwsCloudMapServiceDiscovery']:
        return pulumi.get(self, "a_ws_cloud_map")

    @property
    @pulumi.getter(name="dNS")
    def d_ns(self) -> Optional['outputs.VirtualNodeDnsServiceDiscovery']:
        return pulumi.get(self, "d_ns")


@pulumi.output_type
class VirtualNodeSubjectAlternativeNameMatchers(dict):
    def __init__(__self__, *,
                 exact: Optional[Sequence[str]] = None):
        if exact is not None:
            pulumi.set(__self__, "exact", exact)

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


@pulumi.output_type
class VirtualNodeSubjectAlternativeNames(dict):
    def __init__(__self__, *,
                 match: 'outputs.VirtualNodeSubjectAlternativeNameMatchers'):
        pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def match(self) -> 'outputs.VirtualNodeSubjectAlternativeNameMatchers':
        return pulumi.get(self, "match")


@pulumi.output_type
class VirtualNodeTag(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 VirtualNodeTcpTimeout(dict):
    def __init__(__self__, *,
                 idle: Optional['outputs.VirtualNodeDuration'] = None):
        if idle is not None:
            pulumi.set(__self__, "idle", idle)

    @property
    @pulumi.getter
    def idle(self) -> Optional['outputs.VirtualNodeDuration']:
        return pulumi.get(self, "idle")


@pulumi.output_type
class VirtualNodeTlsValidationContext(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 VirtualNodeTlsValidationContext. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 trust: 'outputs.VirtualNodeTlsValidationContextTrust',
                 subject_alternative_names: Optional['outputs.VirtualNodeSubjectAlternativeNames'] = None):
        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.VirtualNodeTlsValidationContextTrust':
        return pulumi.get(self, "trust")

    @property
    @pulumi.getter(name="subjectAlternativeNames")
    def subject_alternative_names(self) -> Optional['outputs.VirtualNodeSubjectAlternativeNames']:
        return pulumi.get(self, "subject_alternative_names")


@pulumi.output_type
class VirtualNodeTlsValidationContextAcmTrust(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 VirtualNodeTlsValidationContextAcmTrust. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 certificate_authority_arns: Sequence[str]):
        pulumi.set(__self__, "certificate_authority_arns", certificate_authority_arns)

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


@pulumi.output_type
class VirtualNodeTlsValidationContextFileTrust(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 VirtualNodeTlsValidationContextFileTrust. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 certificate_chain: str):
        pulumi.set(__self__, "certificate_chain", certificate_chain)

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


@pulumi.output_type
class VirtualNodeTlsValidationContextSdsTrust(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 VirtualNodeTlsValidationContextSdsTrust. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 secret_name: str):
        pulumi.set(__self__, "secret_name", secret_name)

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


@pulumi.output_type
class VirtualNodeTlsValidationContextTrust(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aCM":
            suggest = "a_cm"
        elif key == "sDS":
            suggest = "s_ds"

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

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

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

    def __init__(__self__, *,
                 a_cm: Optional['outputs.VirtualNodeTlsValidationContextAcmTrust'] = None,
                 file: Optional['outputs.VirtualNodeTlsValidationContextFileTrust'] = None,
                 s_ds: Optional['outputs.VirtualNodeTlsValidationContextSdsTrust'] = None):
        if a_cm is not None:
            pulumi.set(__self__, "a_cm", a_cm)
        if file is not None:
            pulumi.set(__self__, "file", file)
        if s_ds is not None:
            pulumi.set(__self__, "s_ds", s_ds)

    @property
    @pulumi.getter(name="aCM")
    def a_cm(self) -> Optional['outputs.VirtualNodeTlsValidationContextAcmTrust']:
        return pulumi.get(self, "a_cm")

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

    @property
    @pulumi.getter(name="sDS")
    def s_ds(self) -> Optional['outputs.VirtualNodeTlsValidationContextSdsTrust']:
        return pulumi.get(self, "s_ds")


@pulumi.output_type
class VirtualNodeVirtualNodeConnectionPool(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "gRPC":
            suggest = "g_rpc"
        elif key == "hTTP":
            suggest = "h_ttp"
        elif key == "hTTP2":
            suggest = "h_ttp2"
        elif key == "tCP":
            suggest = "t_cp"

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

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

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

    def __init__(__self__, *,
                 g_rpc: Optional['outputs.VirtualNodeVirtualNodeGrpcConnectionPool'] = None,
                 h_ttp: Optional['outputs.VirtualNodeVirtualNodeHttpConnectionPool'] = None,
                 h_ttp2: Optional['outputs.VirtualNodeVirtualNodeHttp2ConnectionPool'] = None,
                 t_cp: Optional['outputs.VirtualNodeVirtualNodeTcpConnectionPool'] = None):
        if g_rpc is not None:
            pulumi.set(__self__, "g_rpc", g_rpc)
        if h_ttp is not None:
            pulumi.set(__self__, "h_ttp", h_ttp)
        if h_ttp2 is not None:
            pulumi.set(__self__, "h_ttp2", h_ttp2)
        if t_cp is not None:
            pulumi.set(__self__, "t_cp", t_cp)

    @property
    @pulumi.getter(name="gRPC")
    def g_rpc(self) -> Optional['outputs.VirtualNodeVirtualNodeGrpcConnectionPool']:
        return pulumi.get(self, "g_rpc")

    @property
    @pulumi.getter(name="hTTP")
    def h_ttp(self) -> Optional['outputs.VirtualNodeVirtualNodeHttpConnectionPool']:
        return pulumi.get(self, "h_ttp")

    @property
    @pulumi.getter(name="hTTP2")
    def h_ttp2(self) -> Optional['outputs.VirtualNodeVirtualNodeHttp2ConnectionPool']:
        return pulumi.get(self, "h_ttp2")

    @property
    @pulumi.getter(name="tCP")
    def t_cp(self) -> Optional['outputs.VirtualNodeVirtualNodeTcpConnectionPool']:
        return pulumi.get(self, "t_cp")


@pulumi.output_type
class VirtualNodeVirtualNodeGrpcConnectionPool(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 VirtualNodeVirtualNodeGrpcConnectionPool. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 max_requests: int):
        pulumi.set(__self__, "max_requests", max_requests)

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


@pulumi.output_type
class VirtualNodeVirtualNodeHttp2ConnectionPool(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 VirtualNodeVirtualNodeHttp2ConnectionPool. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 max_requests: int):
        pulumi.set(__self__, "max_requests", max_requests)

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


@pulumi.output_type
class VirtualNodeVirtualNodeHttpConnectionPool(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 VirtualNodeVirtualNodeHttpConnectionPool. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 max_connections: int,
                 max_pending_requests: Optional[int] = None):
        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:
        return pulumi.get(self, "max_connections")

    @property
    @pulumi.getter(name="maxPendingRequests")
    def max_pending_requests(self) -> Optional[int]:
        return pulumi.get(self, "max_pending_requests")


@pulumi.output_type
class VirtualNodeVirtualNodeSpec(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 VirtualNodeVirtualNodeSpec. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 backend_defaults: Optional['outputs.VirtualNodeBackendDefaults'] = None,
                 backends: Optional[Sequence['outputs.VirtualNodeBackend']] = None,
                 listeners: Optional[Sequence['outputs.VirtualNodeListener']] = None,
                 logging: Optional['outputs.VirtualNodeLogging'] = None,
                 service_discovery: Optional['outputs.VirtualNodeServiceDiscovery'] = None):
        if backend_defaults is not None:
            pulumi.set(__self__, "backend_defaults", backend_defaults)
        if backends is not None:
            pulumi.set(__self__, "backends", backends)
        if listeners is not None:
            pulumi.set(__self__, "listeners", listeners)
        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.VirtualNodeBackendDefaults']:
        return pulumi.get(self, "backend_defaults")

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

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

    @property
    @pulumi.getter
    def logging(self) -> Optional['outputs.VirtualNodeLogging']:
        return pulumi.get(self, "logging")

    @property
    @pulumi.getter(name="serviceDiscovery")
    def service_discovery(self) -> Optional['outputs.VirtualNodeServiceDiscovery']:
        return pulumi.get(self, "service_discovery")


@pulumi.output_type
class VirtualNodeVirtualNodeTcpConnectionPool(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 VirtualNodeVirtualNodeTcpConnectionPool. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 max_connections: int):
        pulumi.set(__self__, "max_connections", max_connections)

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


@pulumi.output_type
class VirtualNodeVirtualServiceBackend(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 VirtualNodeVirtualServiceBackend. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 virtual_service_name: str,
                 client_policy: Optional['outputs.VirtualNodeClientPolicy'] = None):
        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:
        return pulumi.get(self, "virtual_service_name")

    @property
    @pulumi.getter(name="clientPolicy")
    def client_policy(self) -> Optional['outputs.VirtualNodeClientPolicy']:
        return pulumi.get(self, "client_policy")


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

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

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


@pulumi.output_type
class VirtualRouterTag(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 VirtualRouterVirtualRouterListener(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 VirtualRouterVirtualRouterListener. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 port_mapping: 'outputs.VirtualRouterPortMapping'):
        pulumi.set(__self__, "port_mapping", port_mapping)

    @property
    @pulumi.getter(name="portMapping")
    def port_mapping(self) -> 'outputs.VirtualRouterPortMapping':
        return pulumi.get(self, "port_mapping")


@pulumi.output_type
class VirtualRouterVirtualRouterSpec(dict):
    def __init__(__self__, *,
                 listeners: Sequence['outputs.VirtualRouterVirtualRouterListener']):
        pulumi.set(__self__, "listeners", listeners)

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


@pulumi.output_type
class VirtualServiceTag(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 VirtualServiceVirtualNodeServiceProvider(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 VirtualServiceVirtualNodeServiceProvider. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 virtual_node_name: str):
        pulumi.set(__self__, "virtual_node_name", virtual_node_name)

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


@pulumi.output_type
class VirtualServiceVirtualRouterServiceProvider(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 VirtualServiceVirtualRouterServiceProvider. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 virtual_router_name: str):
        pulumi.set(__self__, "virtual_router_name", virtual_router_name)

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


@pulumi.output_type
class VirtualServiceVirtualServiceProvider(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 VirtualServiceVirtualServiceProvider. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 virtual_node: Optional['outputs.VirtualServiceVirtualNodeServiceProvider'] = None,
                 virtual_router: Optional['outputs.VirtualServiceVirtualRouterServiceProvider'] = None):
        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.VirtualServiceVirtualNodeServiceProvider']:
        return pulumi.get(self, "virtual_node")

    @property
    @pulumi.getter(name="virtualRouter")
    def virtual_router(self) -> Optional['outputs.VirtualServiceVirtualRouterServiceProvider']:
        return pulumi.get(self, "virtual_router")


@pulumi.output_type
class VirtualServiceVirtualServiceSpec(dict):
    def __init__(__self__, *,
                 provider: Optional['outputs.VirtualServiceVirtualServiceProvider'] = None):
        if provider is not None:
            pulumi.set(__self__, "provider", provider)

    @property
    @pulumi.getter
    def provider(self) -> Optional['outputs.VirtualServiceVirtualServiceProvider']:
        return pulumi.get(self, "provider")


