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

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

__all__ = [
    'GatewayRouteSpecArgs',
    'GatewayRouteSpecGrpcRouteArgs',
    'GatewayRouteSpecGrpcRouteActionArgs',
    'GatewayRouteSpecGrpcRouteActionTargetArgs',
    'GatewayRouteSpecGrpcRouteActionTargetVirtualServiceArgs',
    'GatewayRouteSpecGrpcRouteMatchArgs',
    'GatewayRouteSpecHttp2RouteArgs',
    'GatewayRouteSpecHttp2RouteActionArgs',
    'GatewayRouteSpecHttp2RouteActionTargetArgs',
    'GatewayRouteSpecHttp2RouteActionTargetVirtualServiceArgs',
    'GatewayRouteSpecHttp2RouteMatchArgs',
    'GatewayRouteSpecHttpRouteArgs',
    'GatewayRouteSpecHttpRouteActionArgs',
    'GatewayRouteSpecHttpRouteActionTargetArgs',
    'GatewayRouteSpecHttpRouteActionTargetVirtualServiceArgs',
    'GatewayRouteSpecHttpRouteMatchArgs',
    'MeshSpecArgs',
    'MeshSpecEgressFilterArgs',
    'RouteSpecArgs',
    'RouteSpecGrpcRouteArgs',
    'RouteSpecGrpcRouteActionArgs',
    'RouteSpecGrpcRouteActionWeightedTargetArgs',
    'RouteSpecGrpcRouteMatchArgs',
    'RouteSpecGrpcRouteMatchMetadataArgs',
    'RouteSpecGrpcRouteMatchMetadataMatchArgs',
    'RouteSpecGrpcRouteMatchMetadataMatchRangeArgs',
    'RouteSpecGrpcRouteRetryPolicyArgs',
    'RouteSpecGrpcRouteRetryPolicyPerRetryTimeoutArgs',
    'RouteSpecGrpcRouteTimeoutArgs',
    'RouteSpecGrpcRouteTimeoutIdleArgs',
    'RouteSpecGrpcRouteTimeoutPerRequestArgs',
    'RouteSpecHttp2RouteArgs',
    'RouteSpecHttp2RouteActionArgs',
    'RouteSpecHttp2RouteActionWeightedTargetArgs',
    'RouteSpecHttp2RouteMatchArgs',
    'RouteSpecHttp2RouteMatchHeaderArgs',
    'RouteSpecHttp2RouteMatchHeaderMatchArgs',
    'RouteSpecHttp2RouteMatchHeaderMatchRangeArgs',
    'RouteSpecHttp2RouteRetryPolicyArgs',
    'RouteSpecHttp2RouteRetryPolicyPerRetryTimeoutArgs',
    'RouteSpecHttp2RouteTimeoutArgs',
    'RouteSpecHttp2RouteTimeoutIdleArgs',
    'RouteSpecHttp2RouteTimeoutPerRequestArgs',
    'RouteSpecHttpRouteArgs',
    'RouteSpecHttpRouteActionArgs',
    'RouteSpecHttpRouteActionWeightedTargetArgs',
    'RouteSpecHttpRouteMatchArgs',
    'RouteSpecHttpRouteMatchHeaderArgs',
    'RouteSpecHttpRouteMatchHeaderMatchArgs',
    'RouteSpecHttpRouteMatchHeaderMatchRangeArgs',
    'RouteSpecHttpRouteRetryPolicyArgs',
    'RouteSpecHttpRouteRetryPolicyPerRetryTimeoutArgs',
    'RouteSpecHttpRouteTimeoutArgs',
    'RouteSpecHttpRouteTimeoutIdleArgs',
    'RouteSpecHttpRouteTimeoutPerRequestArgs',
    'RouteSpecTcpRouteArgs',
    'RouteSpecTcpRouteActionArgs',
    'RouteSpecTcpRouteActionWeightedTargetArgs',
    'RouteSpecTcpRouteTimeoutArgs',
    'RouteSpecTcpRouteTimeoutIdleArgs',
    'VirtualGatewaySpecArgs',
    'VirtualGatewaySpecBackendDefaultsArgs',
    'VirtualGatewaySpecBackendDefaultsClientPolicyArgs',
    'VirtualGatewaySpecBackendDefaultsClientPolicyTlsArgs',
    'VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationArgs',
    'VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustArgs',
    'VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustAcmArgs',
    'VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustFileArgs',
    'VirtualGatewaySpecListenerArgs',
    'VirtualGatewaySpecListenerConnectionPoolArgs',
    'VirtualGatewaySpecListenerConnectionPoolGrpcArgs',
    'VirtualGatewaySpecListenerConnectionPoolHttp2Args',
    'VirtualGatewaySpecListenerConnectionPoolHttpArgs',
    'VirtualGatewaySpecListenerHealthCheckArgs',
    'VirtualGatewaySpecListenerPortMappingArgs',
    'VirtualGatewaySpecListenerTlsArgs',
    'VirtualGatewaySpecListenerTlsCertificateArgs',
    'VirtualGatewaySpecListenerTlsCertificateAcmArgs',
    'VirtualGatewaySpecListenerTlsCertificateFileArgs',
    'VirtualGatewaySpecLoggingArgs',
    'VirtualGatewaySpecLoggingAccessLogArgs',
    'VirtualGatewaySpecLoggingAccessLogFileArgs',
    'VirtualNodeSpecArgs',
    'VirtualNodeSpecBackendArgs',
    'VirtualNodeSpecBackendDefaultsArgs',
    'VirtualNodeSpecBackendDefaultsClientPolicyArgs',
    'VirtualNodeSpecBackendDefaultsClientPolicyTlsArgs',
    'VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationArgs',
    'VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustArgs',
    'VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustAcmArgs',
    'VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustFileArgs',
    'VirtualNodeSpecBackendVirtualServiceArgs',
    'VirtualNodeSpecBackendVirtualServiceClientPolicyArgs',
    'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsArgs',
    'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationArgs',
    'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustArgs',
    'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustAcmArgs',
    'VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustFileArgs',
    'VirtualNodeSpecListenerArgs',
    'VirtualNodeSpecListenerConnectionPoolArgs',
    'VirtualNodeSpecListenerConnectionPoolGrpcArgs',
    'VirtualNodeSpecListenerConnectionPoolHttp2Args',
    'VirtualNodeSpecListenerConnectionPoolHttpArgs',
    'VirtualNodeSpecListenerConnectionPoolTcpArgs',
    'VirtualNodeSpecListenerHealthCheckArgs',
    'VirtualNodeSpecListenerOutlierDetectionArgs',
    'VirtualNodeSpecListenerOutlierDetectionBaseEjectionDurationArgs',
    'VirtualNodeSpecListenerOutlierDetectionIntervalArgs',
    'VirtualNodeSpecListenerPortMappingArgs',
    'VirtualNodeSpecListenerTimeoutArgs',
    'VirtualNodeSpecListenerTimeoutGrpcArgs',
    'VirtualNodeSpecListenerTimeoutGrpcIdleArgs',
    'VirtualNodeSpecListenerTimeoutGrpcPerRequestArgs',
    'VirtualNodeSpecListenerTimeoutHttp2Args',
    'VirtualNodeSpecListenerTimeoutHttp2IdleArgs',
    'VirtualNodeSpecListenerTimeoutHttp2PerRequestArgs',
    'VirtualNodeSpecListenerTimeoutHttpArgs',
    'VirtualNodeSpecListenerTimeoutHttpIdleArgs',
    'VirtualNodeSpecListenerTimeoutHttpPerRequestArgs',
    'VirtualNodeSpecListenerTimeoutTcpArgs',
    'VirtualNodeSpecListenerTimeoutTcpIdleArgs',
    'VirtualNodeSpecListenerTlsArgs',
    'VirtualNodeSpecListenerTlsCertificateArgs',
    'VirtualNodeSpecListenerTlsCertificateAcmArgs',
    'VirtualNodeSpecListenerTlsCertificateFileArgs',
    'VirtualNodeSpecLoggingArgs',
    'VirtualNodeSpecLoggingAccessLogArgs',
    'VirtualNodeSpecLoggingAccessLogFileArgs',
    'VirtualNodeSpecServiceDiscoveryArgs',
    'VirtualNodeSpecServiceDiscoveryAwsCloudMapArgs',
    'VirtualNodeSpecServiceDiscoveryDnsArgs',
    'VirtualRouterSpecArgs',
    'VirtualRouterSpecListenerArgs',
    'VirtualRouterSpecListenerPortMappingArgs',
    'VirtualServiceSpecArgs',
    'VirtualServiceSpecProviderArgs',
    'VirtualServiceSpecProviderVirtualNodeArgs',
    'VirtualServiceSpecProviderVirtualRouterArgs',
]

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

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

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

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

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

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

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


@pulumi.input_type
class GatewayRouteSpecGrpcRouteArgs:
    def __init__(__self__, *,
                 action: pulumi.Input['GatewayRouteSpecGrpcRouteActionArgs'],
                 match: pulumi.Input['GatewayRouteSpecGrpcRouteMatchArgs']):
        """
        :param pulumi.Input['GatewayRouteSpecGrpcRouteActionArgs'] action: The action to take if a match is determined.
        :param pulumi.Input['GatewayRouteSpecGrpcRouteMatchArgs'] match: The criteria for determining a request match.
        """
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "match", match)

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

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

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

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


@pulumi.input_type
class GatewayRouteSpecGrpcRouteActionArgs:
    def __init__(__self__, *,
                 target: pulumi.Input['GatewayRouteSpecGrpcRouteActionTargetArgs']):
        """
        :param pulumi.Input['GatewayRouteSpecGrpcRouteActionTargetArgs'] target: The target that traffic is routed to when a request matches the gateway route.
        """
        pulumi.set(__self__, "target", target)

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

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


@pulumi.input_type
class GatewayRouteSpecGrpcRouteActionTargetArgs:
    def __init__(__self__, *,
                 virtual_service: pulumi.Input['GatewayRouteSpecGrpcRouteActionTargetVirtualServiceArgs']):
        """
        :param pulumi.Input['GatewayRouteSpecGrpcRouteActionTargetVirtualServiceArgs'] virtual_service: The virtual service gateway route target.
        """
        pulumi.set(__self__, "virtual_service", virtual_service)

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

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


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

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

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


@pulumi.input_type
class GatewayRouteSpecGrpcRouteMatchArgs:
    def __init__(__self__, *,
                 service_name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] service_name: The fully qualified domain name for the service to match from the request.
        """
        pulumi.set(__self__, "service_name", service_name)

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

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


@pulumi.input_type
class GatewayRouteSpecHttp2RouteArgs:
    def __init__(__self__, *,
                 action: pulumi.Input['GatewayRouteSpecHttp2RouteActionArgs'],
                 match: pulumi.Input['GatewayRouteSpecHttp2RouteMatchArgs']):
        """
        :param pulumi.Input['GatewayRouteSpecHttp2RouteActionArgs'] action: The action to take if a match is determined.
        :param pulumi.Input['GatewayRouteSpecHttp2RouteMatchArgs'] match: The criteria for determining a request match.
        """
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "match", match)

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

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

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

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


@pulumi.input_type
class GatewayRouteSpecHttp2RouteActionArgs:
    def __init__(__self__, *,
                 target: pulumi.Input['GatewayRouteSpecHttp2RouteActionTargetArgs']):
        """
        :param pulumi.Input['GatewayRouteSpecHttp2RouteActionTargetArgs'] target: The target that traffic is routed to when a request matches the gateway route.
        """
        pulumi.set(__self__, "target", target)

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

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


@pulumi.input_type
class GatewayRouteSpecHttp2RouteActionTargetArgs:
    def __init__(__self__, *,
                 virtual_service: pulumi.Input['GatewayRouteSpecHttp2RouteActionTargetVirtualServiceArgs']):
        """
        :param pulumi.Input['GatewayRouteSpecHttp2RouteActionTargetVirtualServiceArgs'] virtual_service: The virtual service gateway route target.
        """
        pulumi.set(__self__, "virtual_service", virtual_service)

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

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


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

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

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


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

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

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


@pulumi.input_type
class GatewayRouteSpecHttpRouteArgs:
    def __init__(__self__, *,
                 action: pulumi.Input['GatewayRouteSpecHttpRouteActionArgs'],
                 match: pulumi.Input['GatewayRouteSpecHttpRouteMatchArgs']):
        """
        :param pulumi.Input['GatewayRouteSpecHttpRouteActionArgs'] action: The action to take if a match is determined.
        :param pulumi.Input['GatewayRouteSpecHttpRouteMatchArgs'] match: The criteria for determining a request match.
        """
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "match", match)

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

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

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

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


@pulumi.input_type
class GatewayRouteSpecHttpRouteActionArgs:
    def __init__(__self__, *,
                 target: pulumi.Input['GatewayRouteSpecHttpRouteActionTargetArgs']):
        """
        :param pulumi.Input['GatewayRouteSpecHttpRouteActionTargetArgs'] target: The target that traffic is routed to when a request matches the gateway route.
        """
        pulumi.set(__self__, "target", target)

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

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


@pulumi.input_type
class GatewayRouteSpecHttpRouteActionTargetArgs:
    def __init__(__self__, *,
                 virtual_service: pulumi.Input['GatewayRouteSpecHttpRouteActionTargetVirtualServiceArgs']):
        """
        :param pulumi.Input['GatewayRouteSpecHttpRouteActionTargetVirtualServiceArgs'] virtual_service: The virtual service gateway route target.
        """
        pulumi.set(__self__, "virtual_service", virtual_service)

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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

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

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

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

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

    @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['RouteSpecTcpRouteArgs']]:
        """
        The TCP routing information for the route.
        """
        return pulumi.get(self, "tcp_route")

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


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

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

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

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

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

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

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

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

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


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

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

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


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

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

    @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]:
        """
        The relative weight of the weighted target. An integer between 0 and 100.
        """
        return pulumi.get(self, "weight")

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


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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="serviceName")
    def service_name(self) -> Optional[pulumi.Input[str]]:
        """
        The fully qualified domain name for the service to match from the request.
        """
        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 RouteSpecGrpcRouteMatchMetadataArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 invert: Optional[pulumi.Input[bool]] = None,
                 match: Optional[pulumi.Input['RouteSpecGrpcRouteMatchMetadataMatchArgs']] = None):
        """
        :param pulumi.Input[str] name: The name of the route. Must be between 1 and 50 characters in length.
        :param pulumi.Input[bool] invert: If `true`, the match is on the opposite of the `match` criteria. Default is `false`.
        :param pulumi.Input['RouteSpecGrpcRouteMatchMetadataMatchArgs'] match: The data to match from the request.
        """
        pulumi.set(__self__, "name", name)
        if invert is not None:
            pulumi.set(__self__, "invert", invert)
        if match is not None:
            pulumi.set(__self__, "match", match)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the route. Must be between 1 and 50 characters in length.
        """
        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]]:
        """
        If `true`, the match is on the opposite of the `match` criteria. Default is `false`.
        """
        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['RouteSpecGrpcRouteMatchMetadataMatchArgs']]:
        """
        The data to match from the request.
        """
        return pulumi.get(self, "match")

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


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

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

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

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

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

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

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

    @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]]:
        """
        The value sent by the client must end with the specified characters. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "suffix")

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


@pulumi.input_type
class RouteSpecGrpcRouteMatchMetadataMatchRangeArgs:
    def __init__(__self__, *,
                 end: pulumi.Input[int],
                 start: pulumi.Input[int]):
        """
        :param pulumi.Input[int] end: The end of the range.
        :param pulumi.Input[int] start: The start of the range.
        """
        pulumi.set(__self__, "end", end)
        pulumi.set(__self__, "start", start)

    @property
    @pulumi.getter
    def end(self) -> pulumi.Input[int]:
        """
        The end of the range.
        """
        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]:
        """
        The start of the range.
        """
        return pulumi.get(self, "start")

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


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

    @property
    @pulumi.getter(name="maxRetries")
    def max_retries(self) -> pulumi.Input[int]:
        """
        The maximum number of retries.
        """
        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['RouteSpecGrpcRouteRetryPolicyPerRetryTimeoutArgs']:
        """
        The per-retry timeout.
        """
        return pulumi.get(self, "per_retry_timeout")

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

    @property
    @pulumi.getter(name="grpcRetryEvents")
    def grpc_retry_events(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of gRPC retry events.
        Valid values: `cancelled`, `deadline-exceeded`, `internal`, `resource-exhausted`, `unavailable`.
        """
        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]]]]:
        """
        List of HTTP retry events.
        Valid values: `client-error` (HTTP status code 409), `gateway-error` (HTTP status codes 502, 503, and 504), `server-error` (HTTP status codes 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, and 511), `stream-error` (retry on refused stream).
        Valid values: `client-error` (HTTP status code 409), `gateway-error` (HTTP status codes 502, 503, and 504), `server-error` (HTTP status codes 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, and 511), `stream-error` (retry on refused stream).
        """
        return pulumi.get(self, "http_retry_events")

    @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]]]]:
        """
        List of TCP retry events. The only valid value is `connection-error`.
        """
        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 RouteSpecGrpcRouteRetryPolicyPerRetryTimeoutArgs:
    def __init__(__self__, *,
                 unit: pulumi.Input[str],
                 value: pulumi.Input[int]):
        """
        :param pulumi.Input[str] unit: Retry unit. Valid values: `ms`, `s`.
        :param pulumi.Input[int] value: Retry value.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> pulumi.Input[str]:
        """
        Retry unit. Valid values: `ms`, `s`.
        """
        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]:
        """
        Retry value.
        """
        return pulumi.get(self, "value")

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


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

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

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

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

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


@pulumi.input_type
class RouteSpecGrpcRouteTimeoutIdleArgs:
    def __init__(__self__, *,
                 unit: pulumi.Input[str],
                 value: pulumi.Input[int]):
        """
        :param pulumi.Input[str] unit: The unit of time. Valid values: `ms`, `s`.
        :param pulumi.Input[int] value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> pulumi.Input[str]:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        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]:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class RouteSpecGrpcRouteTimeoutPerRequestArgs:
    def __init__(__self__, *,
                 unit: pulumi.Input[str],
                 value: pulumi.Input[int]):
        """
        :param pulumi.Input[str] unit: The unit of time. Valid values: `ms`, `s`.
        :param pulumi.Input[int] value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> pulumi.Input[str]:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        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]:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")

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


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

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

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

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

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

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

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

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

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


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

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

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


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

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

    @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]:
        """
        The relative weight of the weighted target. An integer between 0 and 100.
        """
        return pulumi.get(self, "weight")

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


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

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

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

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

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

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

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

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

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


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

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        A name for the HTTP header in the client request that will be matched on.
        """
        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]]:
        """
        If `true`, the match is on the opposite of the `match` method and value. Default is `false`.
        """
        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['RouteSpecHttp2RouteMatchHeaderMatchArgs']]:
        """
        The method and value to match the header value sent with a request. Specify one match method.
        """
        return pulumi.get(self, "match")

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


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

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

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

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

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

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

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

    @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]]:
        """
        The value sent by the client must end with the specified characters. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "suffix")

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


@pulumi.input_type
class RouteSpecHttp2RouteMatchHeaderMatchRangeArgs:
    def __init__(__self__, *,
                 end: pulumi.Input[int],
                 start: pulumi.Input[int]):
        """
        :param pulumi.Input[int] end: The end of the range.
        :param pulumi.Input[int] start: The start of the range.
        """
        pulumi.set(__self__, "end", end)
        pulumi.set(__self__, "start", start)

    @property
    @pulumi.getter
    def end(self) -> pulumi.Input[int]:
        """
        The end of the range.
        """
        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]:
        """
        The start of the range.
        """
        return pulumi.get(self, "start")

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


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

    @property
    @pulumi.getter(name="maxRetries")
    def max_retries(self) -> pulumi.Input[int]:
        """
        The maximum number of retries.
        """
        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['RouteSpecHttp2RouteRetryPolicyPerRetryTimeoutArgs']:
        """
        The per-retry timeout.
        """
        return pulumi.get(self, "per_retry_timeout")

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

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

    @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]]]]:
        """
        List of TCP retry events. The only valid value is `connection-error`.
        """
        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 RouteSpecHttp2RouteRetryPolicyPerRetryTimeoutArgs:
    def __init__(__self__, *,
                 unit: pulumi.Input[str],
                 value: pulumi.Input[int]):
        """
        :param pulumi.Input[str] unit: Retry unit. Valid values: `ms`, `s`.
        :param pulumi.Input[int] value: Retry value.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> pulumi.Input[str]:
        """
        Retry unit. Valid values: `ms`, `s`.
        """
        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]:
        """
        Retry value.
        """
        return pulumi.get(self, "value")

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


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

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

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

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

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


@pulumi.input_type
class RouteSpecHttp2RouteTimeoutIdleArgs:
    def __init__(__self__, *,
                 unit: pulumi.Input[str],
                 value: pulumi.Input[int]):
        """
        :param pulumi.Input[str] unit: The unit of time. Valid values: `ms`, `s`.
        :param pulumi.Input[int] value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> pulumi.Input[str]:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        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]:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class RouteSpecHttp2RouteTimeoutPerRequestArgs:
    def __init__(__self__, *,
                 unit: pulumi.Input[str],
                 value: pulumi.Input[int]):
        """
        :param pulumi.Input[str] unit: The unit of time. Valid values: `ms`, `s`.
        :param pulumi.Input[int] value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> pulumi.Input[str]:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        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]:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")

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


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

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

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

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

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

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

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

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

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


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

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

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


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

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

    @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]:
        """
        The relative weight of the weighted target. An integer between 0 and 100.
        """
        return pulumi.get(self, "weight")

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


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

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

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

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

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

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

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

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

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


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

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        A name for the HTTP header in the client request that will be matched on.
        """
        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]]:
        """
        If `true`, the match is on the opposite of the `match` method and value. Default is `false`.
        """
        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['RouteSpecHttpRouteMatchHeaderMatchArgs']]:
        """
        The method and value to match the header value sent with a request. Specify one match method.
        """
        return pulumi.get(self, "match")

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


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

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

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

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

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

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

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

    @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]]:
        """
        The value sent by the client must end with the specified characters. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "suffix")

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


@pulumi.input_type
class RouteSpecHttpRouteMatchHeaderMatchRangeArgs:
    def __init__(__self__, *,
                 end: pulumi.Input[int],
                 start: pulumi.Input[int]):
        """
        :param pulumi.Input[int] end: The end of the range.
        :param pulumi.Input[int] start: The start of the range.
        """
        pulumi.set(__self__, "end", end)
        pulumi.set(__self__, "start", start)

    @property
    @pulumi.getter
    def end(self) -> pulumi.Input[int]:
        """
        The end of the range.
        """
        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]:
        """
        The start of the range.
        """
        return pulumi.get(self, "start")

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


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

    @property
    @pulumi.getter(name="maxRetries")
    def max_retries(self) -> pulumi.Input[int]:
        """
        The maximum number of retries.
        """
        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['RouteSpecHttpRouteRetryPolicyPerRetryTimeoutArgs']:
        """
        The per-retry timeout.
        """
        return pulumi.get(self, "per_retry_timeout")

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

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

    @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]]]]:
        """
        List of TCP retry events. The only valid value is `connection-error`.
        """
        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 RouteSpecHttpRouteRetryPolicyPerRetryTimeoutArgs:
    def __init__(__self__, *,
                 unit: pulumi.Input[str],
                 value: pulumi.Input[int]):
        """
        :param pulumi.Input[str] unit: Retry unit. Valid values: `ms`, `s`.
        :param pulumi.Input[int] value: Retry value.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> pulumi.Input[str]:
        """
        Retry unit. Valid values: `ms`, `s`.
        """
        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]:
        """
        Retry value.
        """
        return pulumi.get(self, "value")

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


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

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

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

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

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


@pulumi.input_type
class RouteSpecHttpRouteTimeoutIdleArgs:
    def __init__(__self__, *,
                 unit: pulumi.Input[str],
                 value: pulumi.Input[int]):
        """
        :param pulumi.Input[str] unit: The unit of time. Valid values: `ms`, `s`.
        :param pulumi.Input[int] value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> pulumi.Input[str]:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        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]:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class RouteSpecHttpRouteTimeoutPerRequestArgs:
    def __init__(__self__, *,
                 unit: pulumi.Input[str],
                 value: pulumi.Input[int]):
        """
        :param pulumi.Input[str] unit: The unit of time. Valid values: `ms`, `s`.
        :param pulumi.Input[int] value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> pulumi.Input[str]:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        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]:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")

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


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

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

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

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

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


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

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

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


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

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

    @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]:
        """
        The relative weight of the weighted target. An integer between 0 and 100.
        """
        return pulumi.get(self, "weight")

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


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

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

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


@pulumi.input_type
class RouteSpecTcpRouteTimeoutIdleArgs:
    def __init__(__self__, *,
                 unit: pulumi.Input[str],
                 value: pulumi.Input[int]):
        """
        :param pulumi.Input[str] unit: The unit of time. Valid values: `ms`, `s`.
        :param pulumi.Input[int] value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> pulumi.Input[str]:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        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]:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")

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


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

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

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

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

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

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

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


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

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

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


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

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

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


@pulumi.input_type
class VirtualGatewaySpecBackendDefaultsClientPolicyTlsArgs:
    def __init__(__self__, *,
                 validation: pulumi.Input['VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationArgs'],
                 enforce: Optional[pulumi.Input[bool]] = None,
                 ports: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None):
        """
        :param pulumi.Input['VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationArgs'] validation: The TLS validation context.
        :param pulumi.Input[Sequence[pulumi.Input[int]]] ports: One or more ports that the policy is enforced for.
        """
        pulumi.set(__self__, "validation", validation)
        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['VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationArgs']:
        """
        The TLS validation context.
        """
        return pulumi.get(self, "validation")

    @validation.setter
    def validation(self, value: pulumi.Input['VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationArgs']):
        pulumi.set(self, "validation", 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]]]]:
        """
        One or more ports that the policy is enforced for.
        """
        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 VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationArgs:
    def __init__(__self__, *,
                 trust: pulumi.Input['VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustArgs']):
        """
        :param pulumi.Input['VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustArgs'] trust: The TLS validation context trust.
        """
        pulumi.set(__self__, "trust", trust)

    @property
    @pulumi.getter
    def trust(self) -> pulumi.Input['VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustArgs']:
        """
        The TLS validation context trust.
        """
        return pulumi.get(self, "trust")

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


@pulumi.input_type
class VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustArgs:
    def __init__(__self__, *,
                 acm: Optional[pulumi.Input['VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustAcmArgs']] = None,
                 file: Optional[pulumi.Input['VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustFileArgs']] = None):
        """
        :param pulumi.Input['VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustAcmArgs'] acm: The TLS validation context trust for an AWS Certificate Manager (ACM) certificate.
        :param pulumi.Input['VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustFileArgs'] file: The TLS validation context trust for a local file.
        """
        if acm is not None:
            pulumi.set(__self__, "acm", acm)
        if file is not None:
            pulumi.set(__self__, "file", file)

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

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

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

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


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

    @property
    @pulumi.getter(name="certificateAuthorityArns")
    def certificate_authority_arns(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        One or more ACM Amazon Resource Name (ARN)s.
        """
        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 VirtualGatewaySpecBackendDefaultsClientPolicyTlsValidationTrustFileArgs:
    def __init__(__self__, *,
                 certificate_chain: pulumi.Input[str]):
        """
        :param pulumi.Input[str] certificate_chain: The certificate chain for the certificate. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "certificate_chain", certificate_chain)

    @property
    @pulumi.getter(name="certificateChain")
    def certificate_chain(self) -> pulumi.Input[str]:
        """
        The certificate chain for the certificate. Must be between 1 and 255 characters in length.
        """
        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 VirtualGatewaySpecListenerArgs:
    def __init__(__self__, *,
                 port_mapping: pulumi.Input['VirtualGatewaySpecListenerPortMappingArgs'],
                 connection_pool: Optional[pulumi.Input['VirtualGatewaySpecListenerConnectionPoolArgs']] = None,
                 health_check: Optional[pulumi.Input['VirtualGatewaySpecListenerHealthCheckArgs']] = None,
                 tls: Optional[pulumi.Input['VirtualGatewaySpecListenerTlsArgs']] = None):
        """
        :param pulumi.Input['VirtualGatewaySpecListenerPortMappingArgs'] port_mapping: The port mapping information for the listener.
        :param pulumi.Input['VirtualGatewaySpecListenerConnectionPoolArgs'] connection_pool: The connection pool information for the listener.
        :param pulumi.Input['VirtualGatewaySpecListenerHealthCheckArgs'] health_check: The health check information for the listener.
        :param pulumi.Input['VirtualGatewaySpecListenerTlsArgs'] tls: The Transport Layer Security (TLS) properties for the listener
        """
        pulumi.set(__self__, "port_mapping", port_mapping)
        if connection_pool is not None:
            pulumi.set(__self__, "connection_pool", connection_pool)
        if health_check is not None:
            pulumi.set(__self__, "health_check", health_check)
        if tls is not None:
            pulumi.set(__self__, "tls", tls)

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

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

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

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

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

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

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

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


@pulumi.input_type
class VirtualGatewaySpecListenerConnectionPoolArgs:
    def __init__(__self__, *,
                 grpc: Optional[pulumi.Input['VirtualGatewaySpecListenerConnectionPoolGrpcArgs']] = None,
                 http: Optional[pulumi.Input['VirtualGatewaySpecListenerConnectionPoolHttpArgs']] = None,
                 http2: Optional[pulumi.Input['VirtualGatewaySpecListenerConnectionPoolHttp2Args']] = None):
        """
        :param pulumi.Input['VirtualGatewaySpecListenerConnectionPoolGrpcArgs'] grpc: Connection pool information for gRPC listeners.
        :param pulumi.Input['VirtualGatewaySpecListenerConnectionPoolHttpArgs'] http: Connection pool information for HTTP listeners.
        :param pulumi.Input['VirtualGatewaySpecListenerConnectionPoolHttp2Args'] http2: Connection pool information for HTTP2 listeners.
        """
        if grpc is not None:
            pulumi.set(__self__, "grpc", grpc)
        if http is not None:
            pulumi.set(__self__, "http", http)
        if http2 is not None:
            pulumi.set(__self__, "http2", http2)

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

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

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

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

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

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


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

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

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


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

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

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


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

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

    @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]]:
        """
        Number of overflowing requests after `max_connections` Envoy will queue to upstream cluster. Minimum value of `1`.
        """
        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 VirtualGatewaySpecListenerHealthCheckArgs:
    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):
        """
        :param pulumi.Input[int] healthy_threshold: The number of consecutive successful health checks that must occur before declaring listener healthy.
        :param pulumi.Input[int] interval_millis: The time period in milliseconds between each health check execution.
        :param pulumi.Input[str] protocol: The protocol for the health check request. Valid values are `http`, `http2`, and `grpc`.
        :param pulumi.Input[int] timeout_millis: The amount of time to wait when receiving a response from the health check, in milliseconds.
        :param pulumi.Input[int] unhealthy_threshold: The number of consecutive failed health checks that must occur before declaring a virtual gateway unhealthy.
        :param pulumi.Input[str] path: The destination path for the health check request. This is only required if the specified protocol is `http` or `http2`.
        :param pulumi.Input[int] port: The destination port for the health check request. This port must match the port defined in the `port_mapping` for the listener.
        """
        pulumi.set(__self__, "healthy_threshold", healthy_threshold)
        pulumi.set(__self__, "interval_millis", interval_millis)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "timeout_millis", timeout_millis)
        pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if port is not None:
            pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter(name="healthyThreshold")
    def healthy_threshold(self) -> pulumi.Input[int]:
        """
        The number of consecutive successful health checks that must occur before declaring listener healthy.
        """
        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]:
        """
        The time period in milliseconds between each health check execution.
        """
        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]:
        """
        The protocol for the health check request. Valid values are `http`, `http2`, and `grpc`.
        """
        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]:
        """
        The amount of time to wait when receiving a response from the health check, in milliseconds.
        """
        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]:
        """
        The number of consecutive failed health checks that must occur before declaring a virtual gateway unhealthy.
        """
        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]]:
        """
        The destination path for the health check request. This is only required if the specified protocol is `http` or `http2`.
        """
        return pulumi.get(self, "path")

    @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]]:
        """
        The destination port for the health check request. This port must match the port defined in the `port_mapping` for the listener.
        """
        return pulumi.get(self, "port")

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


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

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[int]:
        """
        The port used for the port mapping.
        """
        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]:
        """
        The protocol used for the port mapping. Valid values are `http`, `http2`, `tcp` and `grpc`.
        """
        return pulumi.get(self, "protocol")

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


@pulumi.input_type
class VirtualGatewaySpecListenerTlsArgs:
    def __init__(__self__, *,
                 certificate: pulumi.Input['VirtualGatewaySpecListenerTlsCertificateArgs'],
                 mode: pulumi.Input[str]):
        """
        :param pulumi.Input['VirtualGatewaySpecListenerTlsCertificateArgs'] certificate: The listener's TLS certificate.
        :param pulumi.Input[str] mode: The listener's TLS mode. Valid values: `DISABLED`, `PERMISSIVE`, `STRICT`.
        """
        pulumi.set(__self__, "certificate", certificate)
        pulumi.set(__self__, "mode", mode)

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

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

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

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


@pulumi.input_type
class VirtualGatewaySpecListenerTlsCertificateArgs:
    def __init__(__self__, *,
                 acm: Optional[pulumi.Input['VirtualGatewaySpecListenerTlsCertificateAcmArgs']] = None,
                 file: Optional[pulumi.Input['VirtualGatewaySpecListenerTlsCertificateFileArgs']] = None):
        """
        :param pulumi.Input['VirtualGatewaySpecListenerTlsCertificateAcmArgs'] acm: An AWS Certificate Manager (ACM) certificate.
        :param pulumi.Input['VirtualGatewaySpecListenerTlsCertificateFileArgs'] file: A local file certificate.
        """
        if acm is not None:
            pulumi.set(__self__, "acm", acm)
        if file is not None:
            pulumi.set(__self__, "file", file)

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

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

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

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


@pulumi.input_type
class VirtualGatewaySpecListenerTlsCertificateAcmArgs:
    def __init__(__self__, *,
                 certificate_arn: pulumi.Input[str]):
        """
        :param pulumi.Input[str] certificate_arn: The Amazon Resource Name (ARN) for the certificate.
        """
        pulumi.set(__self__, "certificate_arn", certificate_arn)

    @property
    @pulumi.getter(name="certificateArn")
    def certificate_arn(self) -> pulumi.Input[str]:
        """
        The Amazon Resource Name (ARN) for the certificate.
        """
        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 VirtualGatewaySpecListenerTlsCertificateFileArgs:
    def __init__(__self__, *,
                 certificate_chain: pulumi.Input[str],
                 private_key: pulumi.Input[str]):
        """
        :param pulumi.Input[str] certificate_chain: The certificate chain for the certificate. Must be between 1 and 255 characters in length.
        :param pulumi.Input[str] private_key: The private key for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "certificate_chain", certificate_chain)
        pulumi.set(__self__, "private_key", private_key)

    @property
    @pulumi.getter(name="certificateChain")
    def certificate_chain(self) -> pulumi.Input[str]:
        """
        The certificate chain for the certificate. Must be between 1 and 255 characters in length.
        """
        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]:
        """
        The private key for a certificate stored on the file system of the mesh endpoint that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "private_key")

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


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

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

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


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

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

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


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

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

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


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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class VirtualNodeSpecBackendArgs:
    def __init__(__self__, *,
                 virtual_service: pulumi.Input['VirtualNodeSpecBackendVirtualServiceArgs']):
        """
        :param pulumi.Input['VirtualNodeSpecBackendVirtualServiceArgs'] virtual_service: Specifies a virtual service to use as a backend for a virtual node.
        """
        pulumi.set(__self__, "virtual_service", virtual_service)

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

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


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

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

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


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

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

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


@pulumi.input_type
class VirtualNodeSpecBackendDefaultsClientPolicyTlsArgs:
    def __init__(__self__, *,
                 validation: pulumi.Input['VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationArgs'],
                 enforce: Optional[pulumi.Input[bool]] = None,
                 ports: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None):
        """
        :param pulumi.Input['VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationArgs'] validation: The TLS validation context.
        :param pulumi.Input[Sequence[pulumi.Input[int]]] ports: One or more ports that the policy is enforced for.
        """
        pulumi.set(__self__, "validation", validation)
        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['VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationArgs']:
        """
        The TLS validation context.
        """
        return pulumi.get(self, "validation")

    @validation.setter
    def validation(self, value: pulumi.Input['VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationArgs']):
        pulumi.set(self, "validation", 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]]]]:
        """
        One or more ports that the policy is enforced for.
        """
        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 VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationArgs:
    def __init__(__self__, *,
                 trust: pulumi.Input['VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustArgs']):
        """
        :param pulumi.Input['VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustArgs'] trust: The TLS validation context trust.
        """
        pulumi.set(__self__, "trust", trust)

    @property
    @pulumi.getter
    def trust(self) -> pulumi.Input['VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustArgs']:
        """
        The TLS validation context trust.
        """
        return pulumi.get(self, "trust")

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


@pulumi.input_type
class VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustArgs:
    def __init__(__self__, *,
                 acm: Optional[pulumi.Input['VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustAcmArgs']] = None,
                 file: Optional[pulumi.Input['VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustFileArgs']] = None):
        """
        :param pulumi.Input['VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustAcmArgs'] acm: The TLS validation context trust for an AWS Certificate Manager (ACM) certificate.
        :param pulumi.Input['VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustFileArgs'] file: The TLS validation context trust for a local file.
        """
        if acm is not None:
            pulumi.set(__self__, "acm", acm)
        if file is not None:
            pulumi.set(__self__, "file", file)

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

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

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

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


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

    @property
    @pulumi.getter(name="certificateAuthorityArns")
    def certificate_authority_arns(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        One or more ACM Amazon Resource Name (ARN)s.
        """
        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 VirtualNodeSpecBackendDefaultsClientPolicyTlsValidationTrustFileArgs:
    def __init__(__self__, *,
                 certificate_chain: pulumi.Input[str]):
        """
        :param pulumi.Input[str] certificate_chain: The certificate chain for the certificate. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "certificate_chain", certificate_chain)

    @property
    @pulumi.getter(name="certificateChain")
    def certificate_chain(self) -> pulumi.Input[str]:
        """
        The certificate chain for the certificate. Must be between 1 and 255 characters in length.
        """
        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 VirtualNodeSpecBackendVirtualServiceArgs:
    def __init__(__self__, *,
                 virtual_service_name: pulumi.Input[str],
                 client_policy: Optional[pulumi.Input['VirtualNodeSpecBackendVirtualServiceClientPolicyArgs']] = None):
        """
        :param pulumi.Input[str] virtual_service_name: The name of the virtual service that is acting as a virtual node backend. Must be between 1 and 255 characters in length.
        :param pulumi.Input['VirtualNodeSpecBackendVirtualServiceClientPolicyArgs'] client_policy: The client policy for the backend.
        """
        pulumi.set(__self__, "virtual_service_name", virtual_service_name)
        if client_policy is not None:
            pulumi.set(__self__, "client_policy", client_policy)

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

    @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['VirtualNodeSpecBackendVirtualServiceClientPolicyArgs']]:
        """
        The client policy for the backend.
        """
        return pulumi.get(self, "client_policy")

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


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

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

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


@pulumi.input_type
class VirtualNodeSpecBackendVirtualServiceClientPolicyTlsArgs:
    def __init__(__self__, *,
                 validation: pulumi.Input['VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationArgs'],
                 enforce: Optional[pulumi.Input[bool]] = None,
                 ports: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None):
        """
        :param pulumi.Input['VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationArgs'] validation: The TLS validation context.
        :param pulumi.Input[Sequence[pulumi.Input[int]]] ports: One or more ports that the policy is enforced for.
        """
        pulumi.set(__self__, "validation", validation)
        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['VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationArgs']:
        """
        The TLS validation context.
        """
        return pulumi.get(self, "validation")

    @validation.setter
    def validation(self, value: pulumi.Input['VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationArgs']):
        pulumi.set(self, "validation", 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]]]]:
        """
        One or more ports that the policy is enforced for.
        """
        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 VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationArgs:
    def __init__(__self__, *,
                 trust: pulumi.Input['VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustArgs']):
        """
        :param pulumi.Input['VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustArgs'] trust: The TLS validation context trust.
        """
        pulumi.set(__self__, "trust", trust)

    @property
    @pulumi.getter
    def trust(self) -> pulumi.Input['VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustArgs']:
        """
        The TLS validation context trust.
        """
        return pulumi.get(self, "trust")

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


@pulumi.input_type
class VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustArgs:
    def __init__(__self__, *,
                 acm: Optional[pulumi.Input['VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustAcmArgs']] = None,
                 file: Optional[pulumi.Input['VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustFileArgs']] = None):
        """
        :param pulumi.Input['VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustAcmArgs'] acm: The TLS validation context trust for an AWS Certificate Manager (ACM) certificate.
        :param pulumi.Input['VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustFileArgs'] file: The TLS validation context trust for a local file.
        """
        if acm is not None:
            pulumi.set(__self__, "acm", acm)
        if file is not None:
            pulumi.set(__self__, "file", file)

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

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

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

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


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

    @property
    @pulumi.getter(name="certificateAuthorityArns")
    def certificate_authority_arns(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        One or more ACM Amazon Resource Name (ARN)s.
        """
        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 VirtualNodeSpecBackendVirtualServiceClientPolicyTlsValidationTrustFileArgs:
    def __init__(__self__, *,
                 certificate_chain: pulumi.Input[str]):
        """
        :param pulumi.Input[str] certificate_chain: The certificate chain for the certificate. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "certificate_chain", certificate_chain)

    @property
    @pulumi.getter(name="certificateChain")
    def certificate_chain(self) -> pulumi.Input[str]:
        """
        The certificate chain for the certificate. Must be between 1 and 255 characters in length.
        """
        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 VirtualNodeSpecListenerArgs:
    def __init__(__self__, *,
                 port_mapping: pulumi.Input['VirtualNodeSpecListenerPortMappingArgs'],
                 connection_pool: Optional[pulumi.Input['VirtualNodeSpecListenerConnectionPoolArgs']] = None,
                 health_check: Optional[pulumi.Input['VirtualNodeSpecListenerHealthCheckArgs']] = None,
                 outlier_detection: Optional[pulumi.Input['VirtualNodeSpecListenerOutlierDetectionArgs']] = None,
                 timeout: Optional[pulumi.Input['VirtualNodeSpecListenerTimeoutArgs']] = None,
                 tls: Optional[pulumi.Input['VirtualNodeSpecListenerTlsArgs']] = None):
        """
        :param pulumi.Input['VirtualNodeSpecListenerPortMappingArgs'] port_mapping: The port mapping information for the listener.
        :param pulumi.Input['VirtualNodeSpecListenerConnectionPoolArgs'] connection_pool: The connection pool information for the listener.
        :param pulumi.Input['VirtualNodeSpecListenerHealthCheckArgs'] health_check: The health check information for the listener.
        :param pulumi.Input['VirtualNodeSpecListenerOutlierDetectionArgs'] outlier_detection: The outlier detection information for the listener.
        :param pulumi.Input['VirtualNodeSpecListenerTimeoutArgs'] timeout: Timeouts for different protocols.
        :param pulumi.Input['VirtualNodeSpecListenerTlsArgs'] tls: The Transport Layer Security (TLS) properties for the listener
        """
        pulumi.set(__self__, "port_mapping", port_mapping)
        if connection_pool is not None:
            pulumi.set(__self__, "connection_pool", connection_pool)
        if health_check is not None:
            pulumi.set(__self__, "health_check", health_check)
        if outlier_detection is not None:
            pulumi.set(__self__, "outlier_detection", outlier_detection)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)
        if tls is not None:
            pulumi.set(__self__, "tls", tls)

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class VirtualNodeSpecListenerConnectionPoolArgs:
    def __init__(__self__, *,
                 grpc: Optional[pulumi.Input['VirtualNodeSpecListenerConnectionPoolGrpcArgs']] = None,
                 http: Optional[pulumi.Input['VirtualNodeSpecListenerConnectionPoolHttpArgs']] = None,
                 http2: Optional[pulumi.Input['VirtualNodeSpecListenerConnectionPoolHttp2Args']] = None,
                 tcp: Optional[pulumi.Input['VirtualNodeSpecListenerConnectionPoolTcpArgs']] = None):
        """
        :param pulumi.Input['VirtualNodeSpecListenerConnectionPoolGrpcArgs'] grpc: Connection pool information for gRPC listeners.
        :param pulumi.Input['VirtualNodeSpecListenerConnectionPoolHttpArgs'] http: Connection pool information for HTTP listeners.
        :param pulumi.Input['VirtualNodeSpecListenerConnectionPoolHttp2Args'] http2: Connection pool information for HTTP2 listeners.
        :param pulumi.Input['VirtualNodeSpecListenerConnectionPoolTcpArgs'] tcp: Connection pool information for TCP listeners.
        """
        if grpc is not None:
            pulumi.set(__self__, "grpc", grpc)
        if http is not None:
            pulumi.set(__self__, "http", http)
        if http2 is not None:
            pulumi.set(__self__, "http2", http2)
        if tcp is not None:
            pulumi.set(__self__, "tcp", tcp)

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

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

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

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

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

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

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

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


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

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

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


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

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

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


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

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

    @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]]:
        """
        Number of overflowing requests after `max_connections` Envoy will queue to upstream cluster. Minimum value of `1`.
        """
        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 VirtualNodeSpecListenerConnectionPoolTcpArgs:
    def __init__(__self__, *,
                 max_connections: pulumi.Input[int]):
        """
        :param pulumi.Input[int] max_connections: Maximum number of outbound TCP connections Envoy can establish concurrently with all hosts in upstream cluster. Minimum value of `1`.
        """
        pulumi.set(__self__, "max_connections", max_connections)

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

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


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

    @property
    @pulumi.getter(name="healthyThreshold")
    def healthy_threshold(self) -> pulumi.Input[int]:
        """
        The number of consecutive successful health checks that must occur before declaring listener healthy.
        """
        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]:
        """
        The time period in milliseconds between each health check execution.
        """
        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]:
        """
        The protocol for the health check request. Valid values are `http`, `http2`, `tcp` and `grpc`.
        """
        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]:
        """
        The amount of time to wait when receiving a response from the health check, in milliseconds.
        """
        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]:
        """
        The number of consecutive failed health checks that must occur before declaring a virtual node unhealthy.
        """
        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]]:
        """
        The destination path for the health check request. This is only required if the specified protocol is `http` or `http2`.
        """
        return pulumi.get(self, "path")

    @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]]:
        """
        The destination port for the health check request. This port must match the port defined in the `port_mapping` for the listener.
        """
        return pulumi.get(self, "port")

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


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

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

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

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

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

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

    @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]:
        """
        Number of consecutive `5xx` errors required for ejection. Minimum value of `1`.
        """
        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 VirtualNodeSpecListenerOutlierDetectionBaseEjectionDurationArgs:
    def __init__(__self__, *,
                 unit: pulumi.Input[str],
                 value: pulumi.Input[int]):
        """
        :param pulumi.Input[str] unit: The unit of time. Valid values: `ms`, `s`.
        :param pulumi.Input[int] value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> pulumi.Input[str]:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        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]:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class VirtualNodeSpecListenerOutlierDetectionIntervalArgs:
    def __init__(__self__, *,
                 unit: pulumi.Input[str],
                 value: pulumi.Input[int]):
        """
        :param pulumi.Input[str] unit: The unit of time. Valid values: `ms`, `s`.
        :param pulumi.Input[int] value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> pulumi.Input[str]:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        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]:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")

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


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

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[int]:
        """
        The port used for the port mapping.
        """
        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]:
        """
        The protocol used for the port mapping. Valid values are `http`, `http2`, `tcp` and `grpc`.
        """
        return pulumi.get(self, "protocol")

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


@pulumi.input_type
class VirtualNodeSpecListenerTimeoutArgs:
    def __init__(__self__, *,
                 grpc: Optional[pulumi.Input['VirtualNodeSpecListenerTimeoutGrpcArgs']] = None,
                 http: Optional[pulumi.Input['VirtualNodeSpecListenerTimeoutHttpArgs']] = None,
                 http2: Optional[pulumi.Input['VirtualNodeSpecListenerTimeoutHttp2Args']] = None,
                 tcp: Optional[pulumi.Input['VirtualNodeSpecListenerTimeoutTcpArgs']] = None):
        """
        :param pulumi.Input['VirtualNodeSpecListenerTimeoutGrpcArgs'] grpc: Timeouts for gRPC listeners.
        :param pulumi.Input['VirtualNodeSpecListenerTimeoutHttpArgs'] http: Timeouts for HTTP listeners.
        :param pulumi.Input['VirtualNodeSpecListenerTimeoutHttp2Args'] http2: Timeouts for HTTP2 listeners.
        :param pulumi.Input['VirtualNodeSpecListenerTimeoutTcpArgs'] tcp: Timeouts for TCP listeners.
        """
        if grpc is not None:
            pulumi.set(__self__, "grpc", grpc)
        if http is not None:
            pulumi.set(__self__, "http", http)
        if http2 is not None:
            pulumi.set(__self__, "http2", http2)
        if tcp is not None:
            pulumi.set(__self__, "tcp", tcp)

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

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

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

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

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

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

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

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


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

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

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

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

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


@pulumi.input_type
class VirtualNodeSpecListenerTimeoutGrpcIdleArgs:
    def __init__(__self__, *,
                 unit: pulumi.Input[str],
                 value: pulumi.Input[int]):
        """
        :param pulumi.Input[str] unit: The unit of time. Valid values: `ms`, `s`.
        :param pulumi.Input[int] value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> pulumi.Input[str]:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        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]:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class VirtualNodeSpecListenerTimeoutGrpcPerRequestArgs:
    def __init__(__self__, *,
                 unit: pulumi.Input[str],
                 value: pulumi.Input[int]):
        """
        :param pulumi.Input[str] unit: The unit of time. Valid values: `ms`, `s`.
        :param pulumi.Input[int] value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> pulumi.Input[str]:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        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]:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")

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


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

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

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

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

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


@pulumi.input_type
class VirtualNodeSpecListenerTimeoutHttp2IdleArgs:
    def __init__(__self__, *,
                 unit: pulumi.Input[str],
                 value: pulumi.Input[int]):
        """
        :param pulumi.Input[str] unit: The unit of time. Valid values: `ms`, `s`.
        :param pulumi.Input[int] value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> pulumi.Input[str]:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        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]:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class VirtualNodeSpecListenerTimeoutHttp2PerRequestArgs:
    def __init__(__self__, *,
                 unit: pulumi.Input[str],
                 value: pulumi.Input[int]):
        """
        :param pulumi.Input[str] unit: The unit of time. Valid values: `ms`, `s`.
        :param pulumi.Input[int] value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> pulumi.Input[str]:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        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]:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")

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


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

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

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

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

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


@pulumi.input_type
class VirtualNodeSpecListenerTimeoutHttpIdleArgs:
    def __init__(__self__, *,
                 unit: pulumi.Input[str],
                 value: pulumi.Input[int]):
        """
        :param pulumi.Input[str] unit: The unit of time. Valid values: `ms`, `s`.
        :param pulumi.Input[int] value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> pulumi.Input[str]:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        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]:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class VirtualNodeSpecListenerTimeoutHttpPerRequestArgs:
    def __init__(__self__, *,
                 unit: pulumi.Input[str],
                 value: pulumi.Input[int]):
        """
        :param pulumi.Input[str] unit: The unit of time. Valid values: `ms`, `s`.
        :param pulumi.Input[int] value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> pulumi.Input[str]:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        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]:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")

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


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

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

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


@pulumi.input_type
class VirtualNodeSpecListenerTimeoutTcpIdleArgs:
    def __init__(__self__, *,
                 unit: pulumi.Input[str],
                 value: pulumi.Input[int]):
        """
        :param pulumi.Input[str] unit: The unit of time. Valid values: `ms`, `s`.
        :param pulumi.Input[int] value: The number of time units. Minimum value of `0`.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> pulumi.Input[str]:
        """
        The unit of time. Valid values: `ms`, `s`.
        """
        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]:
        """
        The number of time units. Minimum value of `0`.
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class VirtualNodeSpecListenerTlsArgs:
    def __init__(__self__, *,
                 certificate: pulumi.Input['VirtualNodeSpecListenerTlsCertificateArgs'],
                 mode: pulumi.Input[str]):
        """
        :param pulumi.Input['VirtualNodeSpecListenerTlsCertificateArgs'] certificate: The listener's TLS certificate.
        :param pulumi.Input[str] mode: The listener's TLS mode. Valid values: `DISABLED`, `PERMISSIVE`, `STRICT`.
        """
        pulumi.set(__self__, "certificate", certificate)
        pulumi.set(__self__, "mode", mode)

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

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

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

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


@pulumi.input_type
class VirtualNodeSpecListenerTlsCertificateArgs:
    def __init__(__self__, *,
                 acm: Optional[pulumi.Input['VirtualNodeSpecListenerTlsCertificateAcmArgs']] = None,
                 file: Optional[pulumi.Input['VirtualNodeSpecListenerTlsCertificateFileArgs']] = None):
        """
        :param pulumi.Input['VirtualNodeSpecListenerTlsCertificateAcmArgs'] acm: An AWS Certificate Manager (ACM) certificate.
        :param pulumi.Input['VirtualNodeSpecListenerTlsCertificateFileArgs'] file: A local file certificate.
        """
        if acm is not None:
            pulumi.set(__self__, "acm", acm)
        if file is not None:
            pulumi.set(__self__, "file", file)

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

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

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

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


@pulumi.input_type
class VirtualNodeSpecListenerTlsCertificateAcmArgs:
    def __init__(__self__, *,
                 certificate_arn: pulumi.Input[str]):
        """
        :param pulumi.Input[str] certificate_arn: The Amazon Resource Name (ARN) for the certificate.
        """
        pulumi.set(__self__, "certificate_arn", certificate_arn)

    @property
    @pulumi.getter(name="certificateArn")
    def certificate_arn(self) -> pulumi.Input[str]:
        """
        The Amazon Resource Name (ARN) for the certificate.
        """
        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 VirtualNodeSpecListenerTlsCertificateFileArgs:
    def __init__(__self__, *,
                 certificate_chain: pulumi.Input[str],
                 private_key: pulumi.Input[str]):
        """
        :param pulumi.Input[str] certificate_chain: The certificate chain for the certificate. Must be between 1 and 255 characters in length.
        :param pulumi.Input[str] private_key: The private key for a certificate stored on the file system of the virtual node that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "certificate_chain", certificate_chain)
        pulumi.set(__self__, "private_key", private_key)

    @property
    @pulumi.getter(name="certificateChain")
    def certificate_chain(self) -> pulumi.Input[str]:
        """
        The certificate chain for the certificate. Must be between 1 and 255 characters in length.
        """
        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]:
        """
        The private key for a certificate stored on the file system of the virtual node that the proxy is running on. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "private_key")

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


@pulumi.input_type
class VirtualNodeSpecLoggingArgs:
    def __init__(__self__, *,
                 access_log: Optional[pulumi.Input['VirtualNodeSpecLoggingAccessLogArgs']] = None):
        """
        :param pulumi.Input['VirtualNodeSpecLoggingAccessLogArgs'] access_log: The access log configuration for a virtual node.
        """
        if access_log is not None:
            pulumi.set(__self__, "access_log", access_log)

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

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


@pulumi.input_type
class VirtualNodeSpecLoggingAccessLogArgs:
    def __init__(__self__, *,
                 file: Optional[pulumi.Input['VirtualNodeSpecLoggingAccessLogFileArgs']] = None):
        """
        :param pulumi.Input['VirtualNodeSpecLoggingAccessLogFileArgs'] file: The file object to send virtual node access logs to.
        """
        if file is not None:
            pulumi.set(__self__, "file", file)

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

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


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

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

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


@pulumi.input_type
class VirtualNodeSpecServiceDiscoveryArgs:
    def __init__(__self__, *,
                 aws_cloud_map: Optional[pulumi.Input['VirtualNodeSpecServiceDiscoveryAwsCloudMapArgs']] = None,
                 dns: Optional[pulumi.Input['VirtualNodeSpecServiceDiscoveryDnsArgs']] = None):
        """
        :param pulumi.Input['VirtualNodeSpecServiceDiscoveryAwsCloudMapArgs'] aws_cloud_map: Specifies any AWS Cloud Map information for the virtual node.
        :param pulumi.Input['VirtualNodeSpecServiceDiscoveryDnsArgs'] dns: Specifies the DNS service name for the virtual node.
        """
        if aws_cloud_map is not None:
            pulumi.set(__self__, "aws_cloud_map", aws_cloud_map)
        if dns is not None:
            pulumi.set(__self__, "dns", dns)

    @property
    @pulumi.getter(name="awsCloudMap")
    def aws_cloud_map(self) -> Optional[pulumi.Input['VirtualNodeSpecServiceDiscoveryAwsCloudMapArgs']]:
        """
        Specifies any AWS Cloud Map information for the virtual node.
        """
        return pulumi.get(self, "aws_cloud_map")

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

    @property
    @pulumi.getter
    def dns(self) -> Optional[pulumi.Input['VirtualNodeSpecServiceDiscoveryDnsArgs']]:
        """
        Specifies the DNS service name for the virtual node.
        """
        return pulumi.get(self, "dns")

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


@pulumi.input_type
class VirtualNodeSpecServiceDiscoveryAwsCloudMapArgs:
    def __init__(__self__, *,
                 namespace_name: pulumi.Input[str],
                 service_name: pulumi.Input[str],
                 attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] namespace_name: The name of the AWS Cloud Map namespace to use.
               Use the `servicediscovery.HttpNamespace` resource to configure a Cloud Map namespace. Must be between 1 and 1024 characters in length.
        :param pulumi.Input[str] service_name: The name of the AWS Cloud Map service to use. Use the `servicediscovery.Service` resource to configure a Cloud Map service. Must be between 1 and 1024 characters in length.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] attributes: A string map that contains attributes with values that you can use to filter instances by any custom attribute that you specified when you registered the instance. Only instances that match all of the specified key/value pairs will be returned.
        """
        pulumi.set(__self__, "namespace_name", namespace_name)
        pulumi.set(__self__, "service_name", service_name)
        if attributes is not None:
            pulumi.set(__self__, "attributes", attributes)

    @property
    @pulumi.getter(name="namespaceName")
    def namespace_name(self) -> pulumi.Input[str]:
        """
        The name of the AWS Cloud Map namespace to use.
        Use the `servicediscovery.HttpNamespace` resource to configure a Cloud Map namespace. Must be between 1 and 1024 characters in length.
        """
        return pulumi.get(self, "namespace_name")

    @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]:
        """
        The name of the AWS Cloud Map service to use. Use the `servicediscovery.Service` resource to configure a Cloud Map service. Must be between 1 and 1024 characters in length.
        """
        return pulumi.get(self, "service_name")

    @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[Mapping[str, pulumi.Input[str]]]]:
        """
        A string map that contains attributes with values that you can use to filter instances by any custom attribute that you specified when you registered the instance. Only instances that match all of the specified key/value pairs will be returned.
        """
        return pulumi.get(self, "attributes")

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


@pulumi.input_type
class VirtualNodeSpecServiceDiscoveryDnsArgs:
    def __init__(__self__, *,
                 hostname: pulumi.Input[str]):
        """
        :param pulumi.Input[str] hostname: The DNS host name for your virtual node.
        """
        pulumi.set(__self__, "hostname", hostname)

    @property
    @pulumi.getter
    def hostname(self) -> pulumi.Input[str]:
        """
        The DNS host name for your virtual node.
        """
        return pulumi.get(self, "hostname")

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


@pulumi.input_type
class VirtualRouterSpecArgs:
    def __init__(__self__, *,
                 listener: pulumi.Input['VirtualRouterSpecListenerArgs']):
        """
        :param pulumi.Input['VirtualRouterSpecListenerArgs'] listener: The listeners that the virtual router is expected to receive inbound traffic from.
               Currently only one listener is supported per virtual router.
        """
        pulumi.set(__self__, "listener", listener)

    @property
    @pulumi.getter
    def listener(self) -> pulumi.Input['VirtualRouterSpecListenerArgs']:
        """
        The listeners that the virtual router is expected to receive inbound traffic from.
        Currently only one listener is supported per virtual router.
        """
        return pulumi.get(self, "listener")

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


@pulumi.input_type
class VirtualRouterSpecListenerArgs:
    def __init__(__self__, *,
                 port_mapping: pulumi.Input['VirtualRouterSpecListenerPortMappingArgs']):
        """
        :param pulumi.Input['VirtualRouterSpecListenerPortMappingArgs'] port_mapping: The port mapping information for the listener.
        """
        pulumi.set(__self__, "port_mapping", port_mapping)

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

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


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

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[int]:
        """
        The port used for the port mapping.
        """
        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]:
        """
        The protocol used for the port mapping. Valid values are `http`,`http2`, `tcp` and `grpc`.
        """
        return pulumi.get(self, "protocol")

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


@pulumi.input_type
class VirtualServiceSpecArgs:
    def __init__(__self__, *,
                 provider: Optional[pulumi.Input['VirtualServiceSpecProviderArgs']] = None):
        """
        :param pulumi.Input['VirtualServiceSpecProviderArgs'] provider: The App Mesh object that is acting as the provider for a virtual service. You can specify a single virtual node or virtual router.
        """
        if provider is not None:
            pulumi.set(__self__, "provider", provider)

    @property
    @pulumi.getter
    def provider(self) -> Optional[pulumi.Input['VirtualServiceSpecProviderArgs']]:
        """
        The App Mesh object that is acting as the provider for a virtual service. You can specify a single virtual node or virtual router.
        """
        return pulumi.get(self, "provider")

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


@pulumi.input_type
class VirtualServiceSpecProviderArgs:
    def __init__(__self__, *,
                 virtual_node: Optional[pulumi.Input['VirtualServiceSpecProviderVirtualNodeArgs']] = None,
                 virtual_router: Optional[pulumi.Input['VirtualServiceSpecProviderVirtualRouterArgs']] = None):
        """
        :param pulumi.Input['VirtualServiceSpecProviderVirtualNodeArgs'] virtual_node: The virtual node associated with a virtual service.
        :param pulumi.Input['VirtualServiceSpecProviderVirtualRouterArgs'] virtual_router: The virtual router associated with a virtual service.
        """
        if virtual_node is not None:
            pulumi.set(__self__, "virtual_node", virtual_node)
        if virtual_router is not None:
            pulumi.set(__self__, "virtual_router", virtual_router)

    @property
    @pulumi.getter(name="virtualNode")
    def virtual_node(self) -> Optional[pulumi.Input['VirtualServiceSpecProviderVirtualNodeArgs']]:
        """
        The virtual node associated with a virtual service.
        """
        return pulumi.get(self, "virtual_node")

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

    @property
    @pulumi.getter(name="virtualRouter")
    def virtual_router(self) -> Optional[pulumi.Input['VirtualServiceSpecProviderVirtualRouterArgs']]:
        """
        The virtual router associated with a virtual service.
        """
        return pulumi.get(self, "virtual_router")

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


@pulumi.input_type
class VirtualServiceSpecProviderVirtualNodeArgs:
    def __init__(__self__, *,
                 virtual_node_name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] virtual_node_name: The name of the virtual node that is acting as a service provider. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "virtual_node_name", virtual_node_name)

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

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


@pulumi.input_type
class VirtualServiceSpecProviderVirtualRouterArgs:
    def __init__(__self__, *,
                 virtual_router_name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] virtual_router_name: The name of the virtual router that is acting as a service provider. Must be between 1 and 255 characters in length.
        """
        pulumi.set(__self__, "virtual_router_name", virtual_router_name)

    @property
    @pulumi.getter(name="virtualRouterName")
    def virtual_router_name(self) -> pulumi.Input[str]:
        """
        The name of the virtual router that is acting as a service provider. Must be between 1 and 255 characters in length.
        """
        return pulumi.get(self, "virtual_router_name")

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


