# 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

__all__ = [
    'GatewayRouteGatewayRouteHostnameMatchArgs',
    'GatewayRouteGatewayRouteHostnameRewriteArgs',
    'GatewayRouteGatewayRouteMetadataMatchArgs',
    'GatewayRouteGatewayRouteRangeMatchArgs',
    'GatewayRouteGatewayRouteSpecArgs',
    'GatewayRouteGatewayRouteTargetArgs',
    'GatewayRouteGatewayRouteVirtualServiceArgs',
    'GatewayRouteGrpcGatewayRouteActionArgs',
    'GatewayRouteGrpcGatewayRouteMatchArgs',
    'GatewayRouteGrpcGatewayRouteMetadataArgs',
    'GatewayRouteGrpcGatewayRouteRewriteArgs',
    'GatewayRouteGrpcGatewayRouteArgs',
    'GatewayRouteHttpGatewayRouteActionArgs',
    'GatewayRouteHttpGatewayRouteHeaderMatchArgs',
    'GatewayRouteHttpGatewayRouteHeaderArgs',
    'GatewayRouteHttpGatewayRouteMatchArgs',
    'GatewayRouteHttpGatewayRoutePathRewriteArgs',
    'GatewayRouteHttpGatewayRoutePrefixRewriteArgs',
    'GatewayRouteHttpGatewayRouteRewriteArgs',
    'GatewayRouteHttpGatewayRouteArgs',
    'GatewayRouteHttpPathMatchArgs',
    'GatewayRouteHttpQueryParameterMatchArgs',
    'GatewayRouteQueryParameterArgs',
    'GatewayRouteTagArgs',
    'MeshEgressFilterArgs',
    'MeshMeshSpecArgs',
    'MeshTagArgs',
    'RouteDurationArgs',
    'RouteGrpcRetryPolicyArgs',
    'RouteGrpcRouteActionArgs',
    'RouteGrpcRouteMatchArgs',
    'RouteGrpcRouteMetadataMatchMethodArgs',
    'RouteGrpcRouteMetadataArgs',
    'RouteGrpcRouteArgs',
    'RouteGrpcTimeoutArgs',
    'RouteHeaderMatchMethodArgs',
    'RouteHttpPathMatchArgs',
    'RouteHttpQueryParameterMatchArgs',
    'RouteHttpRetryPolicyArgs',
    'RouteHttpRouteActionArgs',
    'RouteHttpRouteHeaderArgs',
    'RouteHttpRouteMatchArgs',
    'RouteHttpRouteArgs',
    'RouteHttpTimeoutArgs',
    'RouteMatchRangeArgs',
    'RouteQueryParameterArgs',
    'RouteRouteSpecArgs',
    'RouteTagArgs',
    'RouteTcpRouteActionArgs',
    'RouteTcpRouteArgs',
    'RouteTcpTimeoutArgs',
    'RouteWeightedTargetArgs',
    'VirtualGatewaySubjectAlternativeNameMatchersArgs',
    'VirtualGatewaySubjectAlternativeNamesArgs',
    'VirtualGatewayTagArgs',
    'VirtualGatewayVirtualGatewayAccessLogArgs',
    'VirtualGatewayVirtualGatewayBackendDefaultsArgs',
    'VirtualGatewayVirtualGatewayClientPolicyTlsArgs',
    'VirtualGatewayVirtualGatewayClientPolicyArgs',
    'VirtualGatewayVirtualGatewayClientTlsCertificateArgs',
    'VirtualGatewayVirtualGatewayConnectionPoolArgs',
    'VirtualGatewayVirtualGatewayFileAccessLogArgs',
    'VirtualGatewayVirtualGatewayGrpcConnectionPoolArgs',
    'VirtualGatewayVirtualGatewayHealthCheckPolicyArgs',
    'VirtualGatewayVirtualGatewayHttp2ConnectionPoolArgs',
    'VirtualGatewayVirtualGatewayHttpConnectionPoolArgs',
    'VirtualGatewayVirtualGatewayListenerTlsAcmCertificateArgs',
    'VirtualGatewayVirtualGatewayListenerTlsCertificateArgs',
    'VirtualGatewayVirtualGatewayListenerTlsFileCertificateArgs',
    'VirtualGatewayVirtualGatewayListenerTlsSdsCertificateArgs',
    'VirtualGatewayVirtualGatewayListenerTlsValidationContextTrustArgs',
    'VirtualGatewayVirtualGatewayListenerTlsValidationContextArgs',
    'VirtualGatewayVirtualGatewayListenerTlsArgs',
    'VirtualGatewayVirtualGatewayListenerArgs',
    'VirtualGatewayVirtualGatewayLoggingArgs',
    'VirtualGatewayVirtualGatewayPortMappingArgs',
    'VirtualGatewayVirtualGatewaySpecArgs',
    'VirtualGatewayVirtualGatewayTlsValidationContextAcmTrustArgs',
    'VirtualGatewayVirtualGatewayTlsValidationContextFileTrustArgs',
    'VirtualGatewayVirtualGatewayTlsValidationContextSdsTrustArgs',
    'VirtualGatewayVirtualGatewayTlsValidationContextTrustArgs',
    'VirtualGatewayVirtualGatewayTlsValidationContextArgs',
    'VirtualNodeAccessLogArgs',
    'VirtualNodeAwsCloudMapInstanceAttributeArgs',
    'VirtualNodeAwsCloudMapServiceDiscoveryArgs',
    'VirtualNodeBackendDefaultsArgs',
    'VirtualNodeBackendArgs',
    'VirtualNodeClientPolicyTlsArgs',
    'VirtualNodeClientPolicyArgs',
    'VirtualNodeClientTlsCertificateArgs',
    'VirtualNodeDnsServiceDiscoveryArgs',
    'VirtualNodeDurationArgs',
    'VirtualNodeFileAccessLogArgs',
    'VirtualNodeGrpcTimeoutArgs',
    'VirtualNodeHealthCheckArgs',
    'VirtualNodeHttpTimeoutArgs',
    'VirtualNodeListenerTimeoutArgs',
    'VirtualNodeListenerTlsAcmCertificateArgs',
    'VirtualNodeListenerTlsCertificateArgs',
    'VirtualNodeListenerTlsFileCertificateArgs',
    'VirtualNodeListenerTlsSdsCertificateArgs',
    'VirtualNodeListenerTlsValidationContextTrustArgs',
    'VirtualNodeListenerTlsValidationContextArgs',
    'VirtualNodeListenerTlsArgs',
    'VirtualNodeListenerArgs',
    'VirtualNodeLoggingArgs',
    'VirtualNodeOutlierDetectionArgs',
    'VirtualNodePortMappingArgs',
    'VirtualNodeServiceDiscoveryArgs',
    'VirtualNodeSubjectAlternativeNameMatchersArgs',
    'VirtualNodeSubjectAlternativeNamesArgs',
    'VirtualNodeTagArgs',
    'VirtualNodeTcpTimeoutArgs',
    'VirtualNodeTlsValidationContextAcmTrustArgs',
    'VirtualNodeTlsValidationContextFileTrustArgs',
    'VirtualNodeTlsValidationContextSdsTrustArgs',
    'VirtualNodeTlsValidationContextTrustArgs',
    'VirtualNodeTlsValidationContextArgs',
    'VirtualNodeVirtualNodeConnectionPoolArgs',
    'VirtualNodeVirtualNodeGrpcConnectionPoolArgs',
    'VirtualNodeVirtualNodeHttp2ConnectionPoolArgs',
    'VirtualNodeVirtualNodeHttpConnectionPoolArgs',
    'VirtualNodeVirtualNodeSpecArgs',
    'VirtualNodeVirtualNodeTcpConnectionPoolArgs',
    'VirtualNodeVirtualServiceBackendArgs',
    'VirtualRouterPortMappingArgs',
    'VirtualRouterTagArgs',
    'VirtualRouterVirtualRouterListenerArgs',
    'VirtualRouterVirtualRouterSpecArgs',
    'VirtualServiceTagArgs',
    'VirtualServiceVirtualNodeServiceProviderArgs',
    'VirtualServiceVirtualRouterServiceProviderArgs',
    'VirtualServiceVirtualServiceProviderArgs',
    'VirtualServiceVirtualServiceSpecArgs',
]

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

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

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

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


@pulumi.input_type
class GatewayRouteGatewayRouteHostnameRewriteArgs:
    def __init__(__self__, *,
                 default_target_hostname: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "default_target_hostname")

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


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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class GatewayRouteGatewayRouteRangeMatchArgs:
    def __init__(__self__, *,
                 end: pulumi.Input[int],
                 start: pulumi.Input[int]):
        pulumi.set(__self__, "end", end)
        pulumi.set(__self__, "start", start)

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

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

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

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


@pulumi.input_type
class GatewayRouteGatewayRouteSpecArgs:
    def __init__(__self__, *,
                 grpc_route: Optional[pulumi.Input['GatewayRouteGrpcGatewayRouteArgs']] = None,
                 http2_route: Optional[pulumi.Input['GatewayRouteHttpGatewayRouteArgs']] = None,
                 http_route: Optional[pulumi.Input['GatewayRouteHttpGatewayRouteArgs']] = 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[pulumi.Input['GatewayRouteGrpcGatewayRouteArgs']]:
        return pulumi.get(self, "grpc_route")

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

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

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

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

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


@pulumi.input_type
class GatewayRouteGatewayRouteTargetArgs:
    def __init__(__self__, *,
                 virtual_service: pulumi.Input['GatewayRouteGatewayRouteVirtualServiceArgs']):
        pulumi.set(__self__, "virtual_service", virtual_service)

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

    @virtual_service.setter
    def virtual_service(self, value: pulumi.Input['GatewayRouteGatewayRouteVirtualServiceArgs']):
        pulumi.set(self, "virtual_service", value)


@pulumi.input_type
class GatewayRouteGatewayRouteVirtualServiceArgs:
    def __init__(__self__, *,
                 virtual_service_name: pulumi.Input[str]):
        pulumi.set(__self__, "virtual_service_name", virtual_service_name)

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

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


@pulumi.input_type
class GatewayRouteGrpcGatewayRouteActionArgs:
    def __init__(__self__, *,
                 target: pulumi.Input['GatewayRouteGatewayRouteTargetArgs'],
                 rewrite: Optional[pulumi.Input['GatewayRouteGrpcGatewayRouteRewriteArgs']] = None):
        pulumi.set(__self__, "target", target)
        if rewrite is not None:
            pulumi.set(__self__, "rewrite", rewrite)

    @property
    @pulumi.getter
    def target(self) -> pulumi.Input['GatewayRouteGatewayRouteTargetArgs']:
        return pulumi.get(self, "target")

    @target.setter
    def target(self, value: pulumi.Input['GatewayRouteGatewayRouteTargetArgs']):
        pulumi.set(self, "target", value)

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

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


@pulumi.input_type
class GatewayRouteGrpcGatewayRouteMatchArgs:
    def __init__(__self__, *,
                 hostname: Optional[pulumi.Input['GatewayRouteGatewayRouteHostnameMatchArgs']] = None,
                 metadata: Optional[pulumi.Input[Sequence[pulumi.Input['GatewayRouteGrpcGatewayRouteMetadataArgs']]]] = None,
                 service_name: Optional[pulumi.Input[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[pulumi.Input['GatewayRouteGatewayRouteHostnameMatchArgs']]:
        return pulumi.get(self, "hostname")

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

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

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

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

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


@pulumi.input_type
class GatewayRouteGrpcGatewayRouteMetadataArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 invert: Optional[pulumi.Input[bool]] = None,
                 match: Optional[pulumi.Input['GatewayRouteGatewayRouteMetadataMatchArgs']] = 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) -> pulumi.Input[str]:
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class GatewayRouteGrpcGatewayRouteRewriteArgs:
    def __init__(__self__, *,
                 hostname: Optional[pulumi.Input['GatewayRouteGatewayRouteHostnameRewriteArgs']] = None):
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)

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

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


@pulumi.input_type
class GatewayRouteGrpcGatewayRouteArgs:
    def __init__(__self__, *,
                 action: pulumi.Input['GatewayRouteGrpcGatewayRouteActionArgs'],
                 match: pulumi.Input['GatewayRouteGrpcGatewayRouteMatchArgs']):
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def action(self) -> pulumi.Input['GatewayRouteGrpcGatewayRouteActionArgs']:
        return pulumi.get(self, "action")

    @action.setter
    def action(self, value: pulumi.Input['GatewayRouteGrpcGatewayRouteActionArgs']):
        pulumi.set(self, "action", value)

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

    @match.setter
    def match(self, value: pulumi.Input['GatewayRouteGrpcGatewayRouteMatchArgs']):
        pulumi.set(self, "match", value)


@pulumi.input_type
class GatewayRouteHttpGatewayRouteActionArgs:
    def __init__(__self__, *,
                 target: pulumi.Input['GatewayRouteGatewayRouteTargetArgs'],
                 rewrite: Optional[pulumi.Input['GatewayRouteHttpGatewayRouteRewriteArgs']] = None):
        pulumi.set(__self__, "target", target)
        if rewrite is not None:
            pulumi.set(__self__, "rewrite", rewrite)

    @property
    @pulumi.getter
    def target(self) -> pulumi.Input['GatewayRouteGatewayRouteTargetArgs']:
        return pulumi.get(self, "target")

    @target.setter
    def target(self, value: pulumi.Input['GatewayRouteGatewayRouteTargetArgs']):
        pulumi.set(self, "target", value)

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

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


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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class GatewayRouteHttpGatewayRouteHeaderArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 invert: Optional[pulumi.Input[bool]] = None,
                 match: Optional[pulumi.Input['GatewayRouteHttpGatewayRouteHeaderMatchArgs']] = 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) -> pulumi.Input[str]:
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class GatewayRouteHttpGatewayRouteMatchArgs:
    def __init__(__self__, *,
                 headers: Optional[pulumi.Input[Sequence[pulumi.Input['GatewayRouteHttpGatewayRouteHeaderArgs']]]] = None,
                 hostname: Optional[pulumi.Input['GatewayRouteGatewayRouteHostnameMatchArgs']] = None,
                 method: Optional[pulumi.Input[str]] = None,
                 path: Optional[pulumi.Input['GatewayRouteHttpPathMatchArgs']] = None,
                 prefix: Optional[pulumi.Input[str]] = None,
                 query_parameters: Optional[pulumi.Input[Sequence[pulumi.Input['GatewayRouteQueryParameterArgs']]]] = 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[pulumi.Input[Sequence[pulumi.Input['GatewayRouteHttpGatewayRouteHeaderArgs']]]]:
        return pulumi.get(self, "headers")

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

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

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

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

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

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

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

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

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

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

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


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

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

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


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

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

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

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


@pulumi.input_type
class GatewayRouteHttpGatewayRouteRewriteArgs:
    def __init__(__self__, *,
                 hostname: Optional[pulumi.Input['GatewayRouteGatewayRouteHostnameRewriteArgs']] = None,
                 path: Optional[pulumi.Input['GatewayRouteHttpGatewayRoutePathRewriteArgs']] = None,
                 prefix: Optional[pulumi.Input['GatewayRouteHttpGatewayRoutePrefixRewriteArgs']] = 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[pulumi.Input['GatewayRouteGatewayRouteHostnameRewriteArgs']]:
        return pulumi.get(self, "hostname")

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

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

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

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

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


@pulumi.input_type
class GatewayRouteHttpGatewayRouteArgs:
    def __init__(__self__, *,
                 action: pulumi.Input['GatewayRouteHttpGatewayRouteActionArgs'],
                 match: pulumi.Input['GatewayRouteHttpGatewayRouteMatchArgs']):
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def action(self) -> pulumi.Input['GatewayRouteHttpGatewayRouteActionArgs']:
        return pulumi.get(self, "action")

    @action.setter
    def action(self, value: pulumi.Input['GatewayRouteHttpGatewayRouteActionArgs']):
        pulumi.set(self, "action", value)

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

    @match.setter
    def match(self, value: pulumi.Input['GatewayRouteHttpGatewayRouteMatchArgs']):
        pulumi.set(self, "match", value)


@pulumi.input_type
class GatewayRouteHttpPathMatchArgs:
    def __init__(__self__, *,
                 exact: Optional[pulumi.Input[str]] = None,
                 regex: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "exact")

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

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

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


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

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

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


@pulumi.input_type
class GatewayRouteQueryParameterArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 match: Optional[pulumi.Input['GatewayRouteHttpQueryParameterMatchArgs']] = None):
        pulumi.set(__self__, "name", name)
        if match is not None:
            pulumi.set(__self__, "match", match)

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

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

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

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


@pulumi.input_type
class GatewayRouteTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

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

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


@pulumi.input_type
class MeshEgressFilterArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str]):
        pulumi.set(__self__, "type", type)

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

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


@pulumi.input_type
class MeshMeshSpecArgs:
    def __init__(__self__, *,
                 egress_filter: Optional[pulumi.Input['MeshEgressFilterArgs']] = None):
        if egress_filter is not None:
            pulumi.set(__self__, "egress_filter", egress_filter)

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

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


@pulumi.input_type
class MeshTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

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

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


@pulumi.input_type
class RouteDurationArgs:
    def __init__(__self__, *,
                 unit: pulumi.Input[str],
                 value: pulumi.Input[int]):
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

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

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

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

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


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

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

    @property
    @pulumi.getter(name="perRetryTimeout")
    def per_retry_timeout(self) -> pulumi.Input['RouteDurationArgs']:
        return pulumi.get(self, "per_retry_timeout")

    @per_retry_timeout.setter
    def per_retry_timeout(self, value: pulumi.Input['RouteDurationArgs']):
        pulumi.set(self, "per_retry_timeout", value)

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

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

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

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

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

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


@pulumi.input_type
class RouteGrpcRouteActionArgs:
    def __init__(__self__, *,
                 weighted_targets: pulumi.Input[Sequence[pulumi.Input['RouteWeightedTargetArgs']]]):
        pulumi.set(__self__, "weighted_targets", weighted_targets)

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

    @weighted_targets.setter
    def weighted_targets(self, value: pulumi.Input[Sequence[pulumi.Input['RouteWeightedTargetArgs']]]):
        pulumi.set(self, "weighted_targets", value)


@pulumi.input_type
class RouteGrpcRouteMatchArgs:
    def __init__(__self__, *,
                 metadata: Optional[pulumi.Input[Sequence[pulumi.Input['RouteGrpcRouteMetadataArgs']]]] = None,
                 method_name: Optional[pulumi.Input[str]] = None,
                 service_name: Optional[pulumi.Input[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[pulumi.Input[Sequence[pulumi.Input['RouteGrpcRouteMetadataArgs']]]]:
        return pulumi.get(self, "metadata")

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class RouteGrpcRouteMetadataArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 invert: Optional[pulumi.Input[bool]] = None,
                 match: Optional[pulumi.Input['RouteGrpcRouteMetadataMatchMethodArgs']] = 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) -> pulumi.Input[str]:
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class RouteGrpcRouteArgs:
    def __init__(__self__, *,
                 action: pulumi.Input['RouteGrpcRouteActionArgs'],
                 match: pulumi.Input['RouteGrpcRouteMatchArgs'],
                 retry_policy: Optional[pulumi.Input['RouteGrpcRetryPolicyArgs']] = None,
                 timeout: Optional[pulumi.Input['RouteGrpcTimeoutArgs']] = 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) -> pulumi.Input['RouteGrpcRouteActionArgs']:
        return pulumi.get(self, "action")

    @action.setter
    def action(self, value: pulumi.Input['RouteGrpcRouteActionArgs']):
        pulumi.set(self, "action", value)

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

    @match.setter
    def match(self, value: pulumi.Input['RouteGrpcRouteMatchArgs']):
        pulumi.set(self, "match", value)

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

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

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

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


@pulumi.input_type
class RouteGrpcTimeoutArgs:
    def __init__(__self__, *,
                 idle: Optional[pulumi.Input['RouteDurationArgs']] = None,
                 per_request: Optional[pulumi.Input['RouteDurationArgs']] = 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[pulumi.Input['RouteDurationArgs']]:
        return pulumi.get(self, "idle")

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

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

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


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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class RouteHttpPathMatchArgs:
    def __init__(__self__, *,
                 exact: Optional[pulumi.Input[str]] = None,
                 regex: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "exact")

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

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

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


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

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

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


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

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

    @property
    @pulumi.getter(name="perRetryTimeout")
    def per_retry_timeout(self) -> pulumi.Input['RouteDurationArgs']:
        return pulumi.get(self, "per_retry_timeout")

    @per_retry_timeout.setter
    def per_retry_timeout(self, value: pulumi.Input['RouteDurationArgs']):
        pulumi.set(self, "per_retry_timeout", value)

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

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

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

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


@pulumi.input_type
class RouteHttpRouteActionArgs:
    def __init__(__self__, *,
                 weighted_targets: pulumi.Input[Sequence[pulumi.Input['RouteWeightedTargetArgs']]]):
        pulumi.set(__self__, "weighted_targets", weighted_targets)

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

    @weighted_targets.setter
    def weighted_targets(self, value: pulumi.Input[Sequence[pulumi.Input['RouteWeightedTargetArgs']]]):
        pulumi.set(self, "weighted_targets", value)


@pulumi.input_type
class RouteHttpRouteHeaderArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 invert: Optional[pulumi.Input[bool]] = None,
                 match: Optional[pulumi.Input['RouteHeaderMatchMethodArgs']] = 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) -> pulumi.Input[str]:
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class RouteHttpRouteMatchArgs:
    def __init__(__self__, *,
                 headers: Optional[pulumi.Input[Sequence[pulumi.Input['RouteHttpRouteHeaderArgs']]]] = None,
                 method: Optional[pulumi.Input[str]] = None,
                 path: Optional[pulumi.Input['RouteHttpPathMatchArgs']] = None,
                 prefix: Optional[pulumi.Input[str]] = None,
                 query_parameters: Optional[pulumi.Input[Sequence[pulumi.Input['RouteQueryParameterArgs']]]] = None,
                 scheme: Optional[pulumi.Input[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[pulumi.Input[Sequence[pulumi.Input['RouteHttpRouteHeaderArgs']]]]:
        return pulumi.get(self, "headers")

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class RouteHttpRouteArgs:
    def __init__(__self__, *,
                 action: pulumi.Input['RouteHttpRouteActionArgs'],
                 match: pulumi.Input['RouteHttpRouteMatchArgs'],
                 retry_policy: Optional[pulumi.Input['RouteHttpRetryPolicyArgs']] = None,
                 timeout: Optional[pulumi.Input['RouteHttpTimeoutArgs']] = 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) -> pulumi.Input['RouteHttpRouteActionArgs']:
        return pulumi.get(self, "action")

    @action.setter
    def action(self, value: pulumi.Input['RouteHttpRouteActionArgs']):
        pulumi.set(self, "action", value)

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

    @match.setter
    def match(self, value: pulumi.Input['RouteHttpRouteMatchArgs']):
        pulumi.set(self, "match", value)

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

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

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

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


@pulumi.input_type
class RouteHttpTimeoutArgs:
    def __init__(__self__, *,
                 idle: Optional[pulumi.Input['RouteDurationArgs']] = None,
                 per_request: Optional[pulumi.Input['RouteDurationArgs']] = 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[pulumi.Input['RouteDurationArgs']]:
        return pulumi.get(self, "idle")

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

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

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


@pulumi.input_type
class RouteMatchRangeArgs:
    def __init__(__self__, *,
                 end: pulumi.Input[int],
                 start: pulumi.Input[int]):
        pulumi.set(__self__, "end", end)
        pulumi.set(__self__, "start", start)

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

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

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

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


@pulumi.input_type
class RouteQueryParameterArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 match: Optional[pulumi.Input['RouteHttpQueryParameterMatchArgs']] = None):
        pulumi.set(__self__, "name", name)
        if match is not None:
            pulumi.set(__self__, "match", match)

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

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

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

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


@pulumi.input_type
class RouteRouteSpecArgs:
    def __init__(__self__, *,
                 grpc_route: Optional[pulumi.Input['RouteGrpcRouteArgs']] = None,
                 http2_route: Optional[pulumi.Input['RouteHttpRouteArgs']] = None,
                 http_route: Optional[pulumi.Input['RouteHttpRouteArgs']] = None,
                 priority: Optional[pulumi.Input[int]] = None,
                 tcp_route: Optional[pulumi.Input['RouteTcpRouteArgs']] = 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[pulumi.Input['RouteGrpcRouteArgs']]:
        return pulumi.get(self, "grpc_route")

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class RouteTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

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

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


@pulumi.input_type
class RouteTcpRouteActionArgs:
    def __init__(__self__, *,
                 weighted_targets: pulumi.Input[Sequence[pulumi.Input['RouteWeightedTargetArgs']]]):
        pulumi.set(__self__, "weighted_targets", weighted_targets)

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

    @weighted_targets.setter
    def weighted_targets(self, value: pulumi.Input[Sequence[pulumi.Input['RouteWeightedTargetArgs']]]):
        pulumi.set(self, "weighted_targets", value)


@pulumi.input_type
class RouteTcpRouteArgs:
    def __init__(__self__, *,
                 action: pulumi.Input['RouteTcpRouteActionArgs'],
                 timeout: Optional[pulumi.Input['RouteTcpTimeoutArgs']] = None):
        pulumi.set(__self__, "action", action)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter
    def action(self) -> pulumi.Input['RouteTcpRouteActionArgs']:
        return pulumi.get(self, "action")

    @action.setter
    def action(self, value: pulumi.Input['RouteTcpRouteActionArgs']):
        pulumi.set(self, "action", value)

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

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


@pulumi.input_type
class RouteTcpTimeoutArgs:
    def __init__(__self__, *,
                 idle: Optional[pulumi.Input['RouteDurationArgs']] = None):
        if idle is not None:
            pulumi.set(__self__, "idle", idle)

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

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


@pulumi.input_type
class RouteWeightedTargetArgs:
    def __init__(__self__, *,
                 virtual_node: pulumi.Input[str],
                 weight: pulumi.Input[int]):
        pulumi.set(__self__, "virtual_node", virtual_node)
        pulumi.set(__self__, "weight", weight)

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

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

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

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


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

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

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


@pulumi.input_type
class VirtualGatewaySubjectAlternativeNamesArgs:
    def __init__(__self__, *,
                 match: pulumi.Input['VirtualGatewaySubjectAlternativeNameMatchersArgs']):
        pulumi.set(__self__, "match", match)

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

    @match.setter
    def match(self, value: pulumi.Input['VirtualGatewaySubjectAlternativeNameMatchersArgs']):
        pulumi.set(self, "match", value)


@pulumi.input_type
class VirtualGatewayTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayAccessLogArgs:
    def __init__(__self__, *,
                 file: Optional[pulumi.Input['VirtualGatewayVirtualGatewayFileAccessLogArgs']] = None):
        if file is not None:
            pulumi.set(__self__, "file", file)

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayBackendDefaultsArgs:
    def __init__(__self__, *,
                 client_policy: Optional[pulumi.Input['VirtualGatewayVirtualGatewayClientPolicyArgs']] = None):
        if client_policy is not None:
            pulumi.set(__self__, "client_policy", client_policy)

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayClientPolicyTlsArgs:
    def __init__(__self__, *,
                 validation: pulumi.Input['VirtualGatewayVirtualGatewayTlsValidationContextArgs'],
                 certificate: Optional[pulumi.Input['VirtualGatewayVirtualGatewayClientTlsCertificateArgs']] = None,
                 enforce: Optional[pulumi.Input[bool]] = None,
                 ports: Optional[pulumi.Input[Sequence[pulumi.Input[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) -> pulumi.Input['VirtualGatewayVirtualGatewayTlsValidationContextArgs']:
        return pulumi.get(self, "validation")

    @validation.setter
    def validation(self, value: pulumi.Input['VirtualGatewayVirtualGatewayTlsValidationContextArgs']):
        pulumi.set(self, "validation", value)

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

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

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

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

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayClientPolicyArgs:
    def __init__(__self__, *,
                 t_ls: Optional[pulumi.Input['VirtualGatewayVirtualGatewayClientPolicyTlsArgs']] = None):
        if t_ls is not None:
            pulumi.set(__self__, "t_ls", t_ls)

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayClientTlsCertificateArgs:
    def __init__(__self__, *,
                 file: Optional[pulumi.Input['VirtualGatewayVirtualGatewayListenerTlsFileCertificateArgs']] = None,
                 s_ds: Optional[pulumi.Input['VirtualGatewayVirtualGatewayListenerTlsSdsCertificateArgs']] = 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[pulumi.Input['VirtualGatewayVirtualGatewayListenerTlsFileCertificateArgs']]:
        return pulumi.get(self, "file")

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

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayConnectionPoolArgs:
    def __init__(__self__, *,
                 g_rpc: Optional[pulumi.Input['VirtualGatewayVirtualGatewayGrpcConnectionPoolArgs']] = None,
                 h_ttp: Optional[pulumi.Input['VirtualGatewayVirtualGatewayHttpConnectionPoolArgs']] = None,
                 h_ttp2: Optional[pulumi.Input['VirtualGatewayVirtualGatewayHttp2ConnectionPoolArgs']] = 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[pulumi.Input['VirtualGatewayVirtualGatewayGrpcConnectionPoolArgs']]:
        return pulumi.get(self, "g_rpc")

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

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

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

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayFileAccessLogArgs:
    def __init__(__self__, *,
                 path: pulumi.Input[str]):
        pulumi.set(__self__, "path", path)

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayGrpcConnectionPoolArgs:
    def __init__(__self__, *,
                 max_requests: pulumi.Input[int]):
        pulumi.set(__self__, "max_requests", max_requests)

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayHealthCheckPolicyArgs:
    def __init__(__self__, *,
                 healthy_threshold: pulumi.Input[int],
                 interval_millis: pulumi.Input[int],
                 protocol: pulumi.Input[str],
                 timeout_millis: pulumi.Input[int],
                 unhealthy_threshold: pulumi.Input[int],
                 path: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[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) -> pulumi.Input[int]:
        return pulumi.get(self, "healthy_threshold")

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayHttp2ConnectionPoolArgs:
    def __init__(__self__, *,
                 max_requests: pulumi.Input[int]):
        pulumi.set(__self__, "max_requests", max_requests)

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

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


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

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

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayListenerTlsAcmCertificateArgs:
    def __init__(__self__, *,
                 certificate_arn: pulumi.Input[str]):
        pulumi.set(__self__, "certificate_arn", certificate_arn)

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayListenerTlsCertificateArgs:
    def __init__(__self__, *,
                 a_cm: Optional[pulumi.Input['VirtualGatewayVirtualGatewayListenerTlsAcmCertificateArgs']] = None,
                 file: Optional[pulumi.Input['VirtualGatewayVirtualGatewayListenerTlsFileCertificateArgs']] = None,
                 s_ds: Optional[pulumi.Input['VirtualGatewayVirtualGatewayListenerTlsSdsCertificateArgs']] = 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[pulumi.Input['VirtualGatewayVirtualGatewayListenerTlsAcmCertificateArgs']]:
        return pulumi.get(self, "a_cm")

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

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

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

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayListenerTlsFileCertificateArgs:
    def __init__(__self__, *,
                 certificate_chain: pulumi.Input[str],
                 private_key: pulumi.Input[str]):
        pulumi.set(__self__, "certificate_chain", certificate_chain)
        pulumi.set(__self__, "private_key", private_key)

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

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

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayListenerTlsSdsCertificateArgs:
    def __init__(__self__, *,
                 secret_name: pulumi.Input[str]):
        pulumi.set(__self__, "secret_name", secret_name)

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayListenerTlsValidationContextTrustArgs:
    def __init__(__self__, *,
                 file: Optional[pulumi.Input['VirtualGatewayVirtualGatewayTlsValidationContextFileTrustArgs']] = None,
                 s_ds: Optional[pulumi.Input['VirtualGatewayVirtualGatewayTlsValidationContextSdsTrustArgs']] = 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[pulumi.Input['VirtualGatewayVirtualGatewayTlsValidationContextFileTrustArgs']]:
        return pulumi.get(self, "file")

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

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayListenerTlsValidationContextArgs:
    def __init__(__self__, *,
                 trust: pulumi.Input['VirtualGatewayVirtualGatewayListenerTlsValidationContextTrustArgs'],
                 subject_alternative_names: Optional[pulumi.Input['VirtualGatewaySubjectAlternativeNamesArgs']] = 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) -> pulumi.Input['VirtualGatewayVirtualGatewayListenerTlsValidationContextTrustArgs']:
        return pulumi.get(self, "trust")

    @trust.setter
    def trust(self, value: pulumi.Input['VirtualGatewayVirtualGatewayListenerTlsValidationContextTrustArgs']):
        pulumi.set(self, "trust", value)

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayListenerTlsArgs:
    def __init__(__self__, *,
                 certificate: pulumi.Input['VirtualGatewayVirtualGatewayListenerTlsCertificateArgs'],
                 mode: pulumi.Input[str],
                 validation: Optional[pulumi.Input['VirtualGatewayVirtualGatewayListenerTlsValidationContextArgs']] = 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) -> pulumi.Input['VirtualGatewayVirtualGatewayListenerTlsCertificateArgs']:
        return pulumi.get(self, "certificate")

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

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

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

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayListenerArgs:
    def __init__(__self__, *,
                 port_mapping: pulumi.Input['VirtualGatewayVirtualGatewayPortMappingArgs'],
                 connection_pool: Optional[pulumi.Input['VirtualGatewayVirtualGatewayConnectionPoolArgs']] = None,
                 health_check: Optional[pulumi.Input['VirtualGatewayVirtualGatewayHealthCheckPolicyArgs']] = None,
                 t_ls: Optional[pulumi.Input['VirtualGatewayVirtualGatewayListenerTlsArgs']] = 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) -> pulumi.Input['VirtualGatewayVirtualGatewayPortMappingArgs']:
        return pulumi.get(self, "port_mapping")

    @port_mapping.setter
    def port_mapping(self, value: pulumi.Input['VirtualGatewayVirtualGatewayPortMappingArgs']):
        pulumi.set(self, "port_mapping", value)

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

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

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

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

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayLoggingArgs:
    def __init__(__self__, *,
                 access_log: Optional[pulumi.Input['VirtualGatewayVirtualGatewayAccessLogArgs']] = None):
        if access_log is not None:
            pulumi.set(__self__, "access_log", access_log)

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayPortMappingArgs:
    def __init__(__self__, *,
                 port: pulumi.Input[int],
                 protocol: pulumi.Input[str]):
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "protocol", protocol)

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

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

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewaySpecArgs:
    def __init__(__self__, *,
                 listeners: pulumi.Input[Sequence[pulumi.Input['VirtualGatewayVirtualGatewayListenerArgs']]],
                 backend_defaults: Optional[pulumi.Input['VirtualGatewayVirtualGatewayBackendDefaultsArgs']] = None,
                 logging: Optional[pulumi.Input['VirtualGatewayVirtualGatewayLoggingArgs']] = 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) -> pulumi.Input[Sequence[pulumi.Input['VirtualGatewayVirtualGatewayListenerArgs']]]:
        return pulumi.get(self, "listeners")

    @listeners.setter
    def listeners(self, value: pulumi.Input[Sequence[pulumi.Input['VirtualGatewayVirtualGatewayListenerArgs']]]):
        pulumi.set(self, "listeners", value)

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

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

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayTlsValidationContextAcmTrustArgs:
    def __init__(__self__, *,
                 certificate_authority_arns: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(__self__, "certificate_authority_arns", certificate_authority_arns)

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayTlsValidationContextFileTrustArgs:
    def __init__(__self__, *,
                 certificate_chain: pulumi.Input[str]):
        pulumi.set(__self__, "certificate_chain", certificate_chain)

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayTlsValidationContextSdsTrustArgs:
    def __init__(__self__, *,
                 secret_name: pulumi.Input[str]):
        pulumi.set(__self__, "secret_name", secret_name)

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayTlsValidationContextTrustArgs:
    def __init__(__self__, *,
                 a_cm: Optional[pulumi.Input['VirtualGatewayVirtualGatewayTlsValidationContextAcmTrustArgs']] = None,
                 file: Optional[pulumi.Input['VirtualGatewayVirtualGatewayTlsValidationContextFileTrustArgs']] = None,
                 s_ds: Optional[pulumi.Input['VirtualGatewayVirtualGatewayTlsValidationContextSdsTrustArgs']] = 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[pulumi.Input['VirtualGatewayVirtualGatewayTlsValidationContextAcmTrustArgs']]:
        return pulumi.get(self, "a_cm")

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

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

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

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

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


@pulumi.input_type
class VirtualGatewayVirtualGatewayTlsValidationContextArgs:
    def __init__(__self__, *,
                 trust: pulumi.Input['VirtualGatewayVirtualGatewayTlsValidationContextTrustArgs'],
                 subject_alternative_names: Optional[pulumi.Input['VirtualGatewaySubjectAlternativeNamesArgs']] = 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) -> pulumi.Input['VirtualGatewayVirtualGatewayTlsValidationContextTrustArgs']:
        return pulumi.get(self, "trust")

    @trust.setter
    def trust(self, value: pulumi.Input['VirtualGatewayVirtualGatewayTlsValidationContextTrustArgs']):
        pulumi.set(self, "trust", value)

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

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


@pulumi.input_type
class VirtualNodeAccessLogArgs:
    def __init__(__self__, *,
                 file: Optional[pulumi.Input['VirtualNodeFileAccessLogArgs']] = None):
        if file is not None:
            pulumi.set(__self__, "file", file)

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

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


@pulumi.input_type
class VirtualNodeAwsCloudMapInstanceAttributeArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

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

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


@pulumi.input_type
class VirtualNodeAwsCloudMapServiceDiscoveryArgs:
    def __init__(__self__, *,
                 namespace_name: pulumi.Input[str],
                 service_name: pulumi.Input[str],
                 attributes: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualNodeAwsCloudMapInstanceAttributeArgs']]]] = 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) -> pulumi.Input[str]:
        return pulumi.get(self, "namespace_name")

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

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

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

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

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


@pulumi.input_type
class VirtualNodeBackendDefaultsArgs:
    def __init__(__self__, *,
                 client_policy: Optional[pulumi.Input['VirtualNodeClientPolicyArgs']] = None):
        if client_policy is not None:
            pulumi.set(__self__, "client_policy", client_policy)

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

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


@pulumi.input_type
class VirtualNodeBackendArgs:
    def __init__(__self__, *,
                 virtual_service: Optional[pulumi.Input['VirtualNodeVirtualServiceBackendArgs']] = None):
        if virtual_service is not None:
            pulumi.set(__self__, "virtual_service", virtual_service)

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

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


@pulumi.input_type
class VirtualNodeClientPolicyTlsArgs:
    def __init__(__self__, *,
                 validation: pulumi.Input['VirtualNodeTlsValidationContextArgs'],
                 certificate: Optional[pulumi.Input['VirtualNodeClientTlsCertificateArgs']] = None,
                 enforce: Optional[pulumi.Input[bool]] = None,
                 ports: Optional[pulumi.Input[Sequence[pulumi.Input[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) -> pulumi.Input['VirtualNodeTlsValidationContextArgs']:
        return pulumi.get(self, "validation")

    @validation.setter
    def validation(self, value: pulumi.Input['VirtualNodeTlsValidationContextArgs']):
        pulumi.set(self, "validation", value)

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

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

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

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

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

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


@pulumi.input_type
class VirtualNodeClientPolicyArgs:
    def __init__(__self__, *,
                 t_ls: Optional[pulumi.Input['VirtualNodeClientPolicyTlsArgs']] = None):
        if t_ls is not None:
            pulumi.set(__self__, "t_ls", t_ls)

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

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


@pulumi.input_type
class VirtualNodeClientTlsCertificateArgs:
    def __init__(__self__, *,
                 file: Optional[pulumi.Input['VirtualNodeListenerTlsFileCertificateArgs']] = None,
                 s_ds: Optional[pulumi.Input['VirtualNodeListenerTlsSdsCertificateArgs']] = 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[pulumi.Input['VirtualNodeListenerTlsFileCertificateArgs']]:
        return pulumi.get(self, "file")

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

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

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


@pulumi.input_type
class VirtualNodeDnsServiceDiscoveryArgs:
    def __init__(__self__, *,
                 hostname: pulumi.Input[str],
                 response_type: Optional[pulumi.Input[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) -> pulumi.Input[str]:
        return pulumi.get(self, "hostname")

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

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

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


@pulumi.input_type
class VirtualNodeDurationArgs:
    def __init__(__self__, *,
                 unit: pulumi.Input[str],
                 value: pulumi.Input[int]):
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

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

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

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

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


@pulumi.input_type
class VirtualNodeFileAccessLogArgs:
    def __init__(__self__, *,
                 path: pulumi.Input[str]):
        pulumi.set(__self__, "path", path)

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

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


@pulumi.input_type
class VirtualNodeGrpcTimeoutArgs:
    def __init__(__self__, *,
                 idle: Optional[pulumi.Input['VirtualNodeDurationArgs']] = None,
                 per_request: Optional[pulumi.Input['VirtualNodeDurationArgs']] = 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[pulumi.Input['VirtualNodeDurationArgs']]:
        return pulumi.get(self, "idle")

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

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

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


@pulumi.input_type
class VirtualNodeHealthCheckArgs:
    def __init__(__self__, *,
                 healthy_threshold: pulumi.Input[int],
                 interval_millis: pulumi.Input[int],
                 protocol: pulumi.Input[str],
                 timeout_millis: pulumi.Input[int],
                 unhealthy_threshold: pulumi.Input[int],
                 path: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[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) -> pulumi.Input[int]:
        return pulumi.get(self, "healthy_threshold")

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class VirtualNodeHttpTimeoutArgs:
    def __init__(__self__, *,
                 idle: Optional[pulumi.Input['VirtualNodeDurationArgs']] = None,
                 per_request: Optional[pulumi.Input['VirtualNodeDurationArgs']] = 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[pulumi.Input['VirtualNodeDurationArgs']]:
        return pulumi.get(self, "idle")

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

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

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


@pulumi.input_type
class VirtualNodeListenerTimeoutArgs:
    def __init__(__self__, *,
                 g_rpc: Optional[pulumi.Input['VirtualNodeGrpcTimeoutArgs']] = None,
                 h_ttp: Optional[pulumi.Input['VirtualNodeHttpTimeoutArgs']] = None,
                 h_ttp2: Optional[pulumi.Input['VirtualNodeHttpTimeoutArgs']] = None,
                 t_cp: Optional[pulumi.Input['VirtualNodeTcpTimeoutArgs']] = 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[pulumi.Input['VirtualNodeGrpcTimeoutArgs']]:
        return pulumi.get(self, "g_rpc")

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

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

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

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

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

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

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


@pulumi.input_type
class VirtualNodeListenerTlsAcmCertificateArgs:
    def __init__(__self__, *,
                 certificate_arn: pulumi.Input[str]):
        pulumi.set(__self__, "certificate_arn", certificate_arn)

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

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


@pulumi.input_type
class VirtualNodeListenerTlsCertificateArgs:
    def __init__(__self__, *,
                 a_cm: Optional[pulumi.Input['VirtualNodeListenerTlsAcmCertificateArgs']] = None,
                 file: Optional[pulumi.Input['VirtualNodeListenerTlsFileCertificateArgs']] = None,
                 s_ds: Optional[pulumi.Input['VirtualNodeListenerTlsSdsCertificateArgs']] = 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[pulumi.Input['VirtualNodeListenerTlsAcmCertificateArgs']]:
        return pulumi.get(self, "a_cm")

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

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

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

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

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


@pulumi.input_type
class VirtualNodeListenerTlsFileCertificateArgs:
    def __init__(__self__, *,
                 certificate_chain: pulumi.Input[str],
                 private_key: pulumi.Input[str]):
        pulumi.set(__self__, "certificate_chain", certificate_chain)
        pulumi.set(__self__, "private_key", private_key)

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

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

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

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


@pulumi.input_type
class VirtualNodeListenerTlsSdsCertificateArgs:
    def __init__(__self__, *,
                 secret_name: pulumi.Input[str]):
        pulumi.set(__self__, "secret_name", secret_name)

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

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


@pulumi.input_type
class VirtualNodeListenerTlsValidationContextTrustArgs:
    def __init__(__self__, *,
                 file: Optional[pulumi.Input['VirtualNodeTlsValidationContextFileTrustArgs']] = None,
                 s_ds: Optional[pulumi.Input['VirtualNodeTlsValidationContextSdsTrustArgs']] = 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[pulumi.Input['VirtualNodeTlsValidationContextFileTrustArgs']]:
        return pulumi.get(self, "file")

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

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

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


@pulumi.input_type
class VirtualNodeListenerTlsValidationContextArgs:
    def __init__(__self__, *,
                 trust: pulumi.Input['VirtualNodeListenerTlsValidationContextTrustArgs'],
                 subject_alternative_names: Optional[pulumi.Input['VirtualNodeSubjectAlternativeNamesArgs']] = 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) -> pulumi.Input['VirtualNodeListenerTlsValidationContextTrustArgs']:
        return pulumi.get(self, "trust")

    @trust.setter
    def trust(self, value: pulumi.Input['VirtualNodeListenerTlsValidationContextTrustArgs']):
        pulumi.set(self, "trust", value)

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

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


@pulumi.input_type
class VirtualNodeListenerTlsArgs:
    def __init__(__self__, *,
                 certificate: pulumi.Input['VirtualNodeListenerTlsCertificateArgs'],
                 mode: pulumi.Input[str],
                 validation: Optional[pulumi.Input['VirtualNodeListenerTlsValidationContextArgs']] = 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) -> pulumi.Input['VirtualNodeListenerTlsCertificateArgs']:
        return pulumi.get(self, "certificate")

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

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

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

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

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


@pulumi.input_type
class VirtualNodeListenerArgs:
    def __init__(__self__, *,
                 port_mapping: pulumi.Input['VirtualNodePortMappingArgs'],
                 connection_pool: Optional[pulumi.Input['VirtualNodeVirtualNodeConnectionPoolArgs']] = None,
                 health_check: Optional[pulumi.Input['VirtualNodeHealthCheckArgs']] = None,
                 outlier_detection: Optional[pulumi.Input['VirtualNodeOutlierDetectionArgs']] = None,
                 t_ls: Optional[pulumi.Input['VirtualNodeListenerTlsArgs']] = None,
                 timeout: Optional[pulumi.Input['VirtualNodeListenerTimeoutArgs']] = 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) -> pulumi.Input['VirtualNodePortMappingArgs']:
        return pulumi.get(self, "port_mapping")

    @port_mapping.setter
    def port_mapping(self, value: pulumi.Input['VirtualNodePortMappingArgs']):
        pulumi.set(self, "port_mapping", value)

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class VirtualNodeLoggingArgs:
    def __init__(__self__, *,
                 access_log: Optional[pulumi.Input['VirtualNodeAccessLogArgs']] = None):
        if access_log is not None:
            pulumi.set(__self__, "access_log", access_log)

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

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


@pulumi.input_type
class VirtualNodeOutlierDetectionArgs:
    def __init__(__self__, *,
                 base_ejection_duration: pulumi.Input['VirtualNodeDurationArgs'],
                 interval: pulumi.Input['VirtualNodeDurationArgs'],
                 max_ejection_percent: pulumi.Input[int],
                 max_server_errors: pulumi.Input[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) -> pulumi.Input['VirtualNodeDurationArgs']:
        return pulumi.get(self, "base_ejection_duration")

    @base_ejection_duration.setter
    def base_ejection_duration(self, value: pulumi.Input['VirtualNodeDurationArgs']):
        pulumi.set(self, "base_ejection_duration", value)

    @property
    @pulumi.getter
    def interval(self) -> pulumi.Input['VirtualNodeDurationArgs']:
        return pulumi.get(self, "interval")

    @interval.setter
    def interval(self, value: pulumi.Input['VirtualNodeDurationArgs']):
        pulumi.set(self, "interval", value)

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

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

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

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


@pulumi.input_type
class VirtualNodePortMappingArgs:
    def __init__(__self__, *,
                 port: pulumi.Input[int],
                 protocol: pulumi.Input[str]):
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "protocol", protocol)

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

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

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

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


@pulumi.input_type
class VirtualNodeServiceDiscoveryArgs:
    def __init__(__self__, *,
                 a_ws_cloud_map: Optional[pulumi.Input['VirtualNodeAwsCloudMapServiceDiscoveryArgs']] = None,
                 d_ns: Optional[pulumi.Input['VirtualNodeDnsServiceDiscoveryArgs']] = 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[pulumi.Input['VirtualNodeAwsCloudMapServiceDiscoveryArgs']]:
        return pulumi.get(self, "a_ws_cloud_map")

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

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

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


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

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

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


@pulumi.input_type
class VirtualNodeSubjectAlternativeNamesArgs:
    def __init__(__self__, *,
                 match: pulumi.Input['VirtualNodeSubjectAlternativeNameMatchersArgs']):
        pulumi.set(__self__, "match", match)

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

    @match.setter
    def match(self, value: pulumi.Input['VirtualNodeSubjectAlternativeNameMatchersArgs']):
        pulumi.set(self, "match", value)


@pulumi.input_type
class VirtualNodeTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

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

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


@pulumi.input_type
class VirtualNodeTcpTimeoutArgs:
    def __init__(__self__, *,
                 idle: Optional[pulumi.Input['VirtualNodeDurationArgs']] = None):
        if idle is not None:
            pulumi.set(__self__, "idle", idle)

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

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


@pulumi.input_type
class VirtualNodeTlsValidationContextAcmTrustArgs:
    def __init__(__self__, *,
                 certificate_authority_arns: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(__self__, "certificate_authority_arns", certificate_authority_arns)

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

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


@pulumi.input_type
class VirtualNodeTlsValidationContextFileTrustArgs:
    def __init__(__self__, *,
                 certificate_chain: pulumi.Input[str]):
        pulumi.set(__self__, "certificate_chain", certificate_chain)

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

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


@pulumi.input_type
class VirtualNodeTlsValidationContextSdsTrustArgs:
    def __init__(__self__, *,
                 secret_name: pulumi.Input[str]):
        pulumi.set(__self__, "secret_name", secret_name)

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

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


@pulumi.input_type
class VirtualNodeTlsValidationContextTrustArgs:
    def __init__(__self__, *,
                 a_cm: Optional[pulumi.Input['VirtualNodeTlsValidationContextAcmTrustArgs']] = None,
                 file: Optional[pulumi.Input['VirtualNodeTlsValidationContextFileTrustArgs']] = None,
                 s_ds: Optional[pulumi.Input['VirtualNodeTlsValidationContextSdsTrustArgs']] = 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[pulumi.Input['VirtualNodeTlsValidationContextAcmTrustArgs']]:
        return pulumi.get(self, "a_cm")

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

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

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

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

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


@pulumi.input_type
class VirtualNodeTlsValidationContextArgs:
    def __init__(__self__, *,
                 trust: pulumi.Input['VirtualNodeTlsValidationContextTrustArgs'],
                 subject_alternative_names: Optional[pulumi.Input['VirtualNodeSubjectAlternativeNamesArgs']] = 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) -> pulumi.Input['VirtualNodeTlsValidationContextTrustArgs']:
        return pulumi.get(self, "trust")

    @trust.setter
    def trust(self, value: pulumi.Input['VirtualNodeTlsValidationContextTrustArgs']):
        pulumi.set(self, "trust", value)

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

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


@pulumi.input_type
class VirtualNodeVirtualNodeConnectionPoolArgs:
    def __init__(__self__, *,
                 g_rpc: Optional[pulumi.Input['VirtualNodeVirtualNodeGrpcConnectionPoolArgs']] = None,
                 h_ttp: Optional[pulumi.Input['VirtualNodeVirtualNodeHttpConnectionPoolArgs']] = None,
                 h_ttp2: Optional[pulumi.Input['VirtualNodeVirtualNodeHttp2ConnectionPoolArgs']] = None,
                 t_cp: Optional[pulumi.Input['VirtualNodeVirtualNodeTcpConnectionPoolArgs']] = 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[pulumi.Input['VirtualNodeVirtualNodeGrpcConnectionPoolArgs']]:
        return pulumi.get(self, "g_rpc")

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

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

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

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

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

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

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


@pulumi.input_type
class VirtualNodeVirtualNodeGrpcConnectionPoolArgs:
    def __init__(__self__, *,
                 max_requests: pulumi.Input[int]):
        pulumi.set(__self__, "max_requests", max_requests)

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

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


@pulumi.input_type
class VirtualNodeVirtualNodeHttp2ConnectionPoolArgs:
    def __init__(__self__, *,
                 max_requests: pulumi.Input[int]):
        pulumi.set(__self__, "max_requests", max_requests)

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

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


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

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

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

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


@pulumi.input_type
class VirtualNodeVirtualNodeSpecArgs:
    def __init__(__self__, *,
                 backend_defaults: Optional[pulumi.Input['VirtualNodeBackendDefaultsArgs']] = None,
                 backends: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualNodeBackendArgs']]]] = None,
                 listeners: Optional[pulumi.Input[Sequence[pulumi.Input['VirtualNodeListenerArgs']]]] = None,
                 logging: Optional[pulumi.Input['VirtualNodeLoggingArgs']] = None,
                 service_discovery: Optional[pulumi.Input['VirtualNodeServiceDiscoveryArgs']] = 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[pulumi.Input['VirtualNodeBackendDefaultsArgs']]:
        return pulumi.get(self, "backend_defaults")

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class VirtualNodeVirtualNodeTcpConnectionPoolArgs:
    def __init__(__self__, *,
                 max_connections: pulumi.Input[int]):
        pulumi.set(__self__, "max_connections", max_connections)

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

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


@pulumi.input_type
class VirtualNodeVirtualServiceBackendArgs:
    def __init__(__self__, *,
                 virtual_service_name: pulumi.Input[str],
                 client_policy: Optional[pulumi.Input['VirtualNodeClientPolicyArgs']] = 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) -> pulumi.Input[str]:
        return pulumi.get(self, "virtual_service_name")

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

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

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


@pulumi.input_type
class VirtualRouterPortMappingArgs:
    def __init__(__self__, *,
                 port: pulumi.Input[int],
                 protocol: pulumi.Input[str]):
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "protocol", protocol)

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

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

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

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


@pulumi.input_type
class VirtualRouterTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

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

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


@pulumi.input_type
class VirtualRouterVirtualRouterListenerArgs:
    def __init__(__self__, *,
                 port_mapping: pulumi.Input['VirtualRouterPortMappingArgs']):
        pulumi.set(__self__, "port_mapping", port_mapping)

    @property
    @pulumi.getter(name="portMapping")
    def port_mapping(self) -> pulumi.Input['VirtualRouterPortMappingArgs']:
        return pulumi.get(self, "port_mapping")

    @port_mapping.setter
    def port_mapping(self, value: pulumi.Input['VirtualRouterPortMappingArgs']):
        pulumi.set(self, "port_mapping", value)


@pulumi.input_type
class VirtualRouterVirtualRouterSpecArgs:
    def __init__(__self__, *,
                 listeners: pulumi.Input[Sequence[pulumi.Input['VirtualRouterVirtualRouterListenerArgs']]]):
        pulumi.set(__self__, "listeners", listeners)

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

    @listeners.setter
    def listeners(self, value: pulumi.Input[Sequence[pulumi.Input['VirtualRouterVirtualRouterListenerArgs']]]):
        pulumi.set(self, "listeners", value)


@pulumi.input_type
class VirtualServiceTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

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

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


@pulumi.input_type
class VirtualServiceVirtualNodeServiceProviderArgs:
    def __init__(__self__, *,
                 virtual_node_name: pulumi.Input[str]):
        pulumi.set(__self__, "virtual_node_name", virtual_node_name)

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

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


@pulumi.input_type
class VirtualServiceVirtualRouterServiceProviderArgs:
    def __init__(__self__, *,
                 virtual_router_name: pulumi.Input[str]):
        pulumi.set(__self__, "virtual_router_name", virtual_router_name)

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

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


@pulumi.input_type
class VirtualServiceVirtualServiceProviderArgs:
    def __init__(__self__, *,
                 virtual_node: Optional[pulumi.Input['VirtualServiceVirtualNodeServiceProviderArgs']] = None,
                 virtual_router: Optional[pulumi.Input['VirtualServiceVirtualRouterServiceProviderArgs']] = 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[pulumi.Input['VirtualServiceVirtualNodeServiceProviderArgs']]:
        return pulumi.get(self, "virtual_node")

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

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

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


@pulumi.input_type
class VirtualServiceVirtualServiceSpecArgs:
    def __init__(__self__, *,
                 provider: Optional[pulumi.Input['VirtualServiceVirtualServiceProviderArgs']] = None):
        if provider is not None:
            pulumi.set(__self__, "provider", provider)

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

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


