aws-cdk-lib 2.172.0__py3-none-any.whl → 2.173.1__py3-none-any.whl

aws_cdk/aws_route53/__init__.py

@@ -231,6 +231,43 @@ Constructs are available for A, AAAA, CAA, CNAME, MX, NS, SRV and TXT records.
 Use the `CaaAmazonRecord` construct to easily restrict certificate authorities
 allowed to issue certificates for a domain to Amazon only.
 
+### Health Checks
+
+See the [Route 53 Health Checks documentation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53-healthcheck-healthcheckconfig.html#cfn-route53-healthcheck-healthcheckconfig-type) for possible types of health checks.
+
+Route 53 has the ability to monitor the health of your application and only return records for healthy endpoints.
+This is done using a `HealthCheck` construct.
+
+In the following example, the `ARecord` will be returned by Route 53 in response to DNS queries only if the HTTP requests to the `example.com/health` endpoint return a 2XX or 3XX status code.
+
+In case, when the endpoint is not healthy, the `ARecord2` will be returned by Route 53 in response to DNS queries.
+
+```python
+# my_zone: route53.HostedZone
+
+
+health_check = route53.HealthCheck(self, "HealthCheck",
+    type=route53.HealthCheckType.HTTP,
+    fqdn="example.com",
+    port=80,
+    resource_path="/health",
+    failure_threshold=3,
+    request_interval=Duration.seconds(30)
+)
+
+route53.ARecord(self, "ARecord",
+    zone=my_zone,
+    target=route53.RecordTarget.from_ip_addresses("1.2.3.4"),
+    health_check=health_check,
+    weight=100
+)
+route53.ARecord(self, "ARecord2",
+    zone=my_zone,
+    target=route53.RecordTarget.from_ip_addresses("5.6.7.8"),
+    weight=0
+)
+```
+
 ### Replacing existing record sets (dangerous!)
 
 Use the `deleteExisting` prop to delete an existing record set before deploying the new one.
@@ -586,17 +623,88 @@ from ..aws_iam import (
 from ..aws_kms import IKey as _IKey_5f11635f
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_route53.AlarmIdentifier",
+    jsii_struct_bases=[],
+    name_mapping={"name": "name", "region": "region"},
+)
+class AlarmIdentifier:
+    def __init__(self, *, name: builtins.str, region: builtins.str) -> None:
+        '''A CloudWatch alarm that you want Amazon Route 53 health checker to use to determine whether this health check is healthy.
+
+        :param name: The name of the CloudWatch alarm that you want Amazon Route 53 health checkers to use to determine whether this health check is healthy.
+        :param region: The region of the CloudWatch alarm that you want Amazon Route 53 health checkers to use to determine whether this health check is healthy.
+
+        :exampleMetadata: fixture=_generated
+
+        Example::
+
+            # The code below shows an example of how to instantiate this type.
+            # The values are placeholders you should change.
+            from aws_cdk import aws_route53 as route53
+            
+            alarm_identifier = route53.AlarmIdentifier(
+                name="name",
+                region="region"
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__fcd95e6a7e14c758d746168914f9e2a2b5cd382fbfbc8277ef45a5aee3a652fa)
+            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
+            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "name": name,
+            "region": region,
+        }
+
+    @builtins.property
+    def name(self) -> builtins.str:
+        '''The name of the CloudWatch alarm that you want Amazon Route 53 health checkers to use to determine whether this health check is healthy.'''
+        result = self._values.get("name")
+        assert result is not None, "Required property 'name' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def region(self) -> builtins.str:
+        '''The region of the CloudWatch alarm that you want Amazon Route 53 health checkers to use to determine whether this health check is healthy.'''
+        result = self._values.get("region")
+        assert result is not None, "Required property 'region' is missing"
+        return typing.cast(builtins.str, result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "AlarmIdentifier(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_route53.AliasRecordTargetConfig",
     jsii_struct_bases=[],
-    name_mapping={"dns_name": "dnsName", "hosted_zone_id": "hostedZoneId"},
+    name_mapping={
+        "dns_name": "dnsName",
+        "hosted_zone_id": "hostedZoneId",
+        "evaluate_target_health": "evaluateTargetHealth",
+    },
 )
 class AliasRecordTargetConfig:
-    def __init__(self, *, dns_name: builtins.str, hosted_zone_id: builtins.str) -> None:
+    def __init__(
+        self,
+        *,
+        dns_name: builtins.str,
+        hosted_zone_id: builtins.str,
+        evaluate_target_health: typing.Optional[builtins.bool] = None,
+    ) -> None:
         '''Represents the properties of an alias target destination.
 
         :param dns_name: DNS name of the target.
         :param hosted_zone_id: Hosted zone ID of the target.
+        :param evaluate_target_health: Evaluate the target health. Default: - no health check configuration
 
         :exampleMetadata: fixture=_generated
 
@@ -608,17 +716,23 @@ class AliasRecordTargetConfig:
             
             alias_record_target_config = route53.AliasRecordTargetConfig(
                 dns_name="dnsName",
-                hosted_zone_id="hostedZoneId"
+                hosted_zone_id="hostedZoneId",
+            
+                # the properties below are optional
+                evaluate_target_health=False
             )
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__387b486cd004971b31128e4032ad0c37e74eea08888305d1660803aa68158e99)
             check_type(argname="argument dns_name", value=dns_name, expected_type=type_hints["dns_name"])
             check_type(argname="argument hosted_zone_id", value=hosted_zone_id, expected_type=type_hints["hosted_zone_id"])
+            check_type(argname="argument evaluate_target_health", value=evaluate_target_health, expected_type=type_hints["evaluate_target_health"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "dns_name": dns_name,
             "hosted_zone_id": hosted_zone_id,
         }
+        if evaluate_target_health is not None:
+            self._values["evaluate_target_health"] = evaluate_target_health
 
     @builtins.property
     def dns_name(self) -> builtins.str:
@@ -634,6 +748,15 @@ class AliasRecordTargetConfig:
         assert result is not None, "Required property 'hosted_zone_id' is missing"
         return typing.cast(builtins.str, result)
 
+    @builtins.property
+    def evaluate_target_health(self) -> typing.Optional[builtins.bool]:
+        '''Evaluate the target health.
+
+        :default: - no health check configuration
+        '''
+        result = self._values.get("evaluate_target_health")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -6538,6 +6661,447 @@ class GeoLocation(
         return typing.cast(typing.Optional[builtins.str], jsii.get(self, "subdivisionCode"))
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_route53.HealthCheckProps",
+    jsii_struct_bases=[],
+    name_mapping={
+        "type": "type",
+        "alarm_identifier": "alarmIdentifier",
+        "child_health_checks": "childHealthChecks",
+        "enable_sni": "enableSNI",
+        "failure_threshold": "failureThreshold",
+        "fqdn": "fqdn",
+        "health_threshold": "healthThreshold",
+        "insufficient_data_health_status": "insufficientDataHealthStatus",
+        "inverted": "inverted",
+        "ip_address": "ipAddress",
+        "measure_latency": "measureLatency",
+        "port": "port",
+        "regions": "regions",
+        "request_interval": "requestInterval",
+        "resource_path": "resourcePath",
+        "routing_control": "routingControl",
+        "search_string": "searchString",
+    },
+)
+class HealthCheckProps:
+    def __init__(
+        self,
+        *,
+        type: "HealthCheckType",
+        alarm_identifier: typing.Optional[typing.Union[AlarmIdentifier, typing.Dict[builtins.str, typing.Any]]] = None,
+        child_health_checks: typing.Optional[typing.Sequence["IHealthCheck"]] = None,
+        enable_sni: typing.Optional[builtins.bool] = None,
+        failure_threshold: typing.Optional[jsii.Number] = None,
+        fqdn: typing.Optional[builtins.str] = None,
+        health_threshold: typing.Optional[jsii.Number] = None,
+        insufficient_data_health_status: typing.Optional["InsufficientDataHealthStatusEnum"] = None,
+        inverted: typing.Optional[builtins.bool] = None,
+        ip_address: typing.Optional[builtins.str] = None,
+        measure_latency: typing.Optional[builtins.bool] = None,
+        port: typing.Optional[jsii.Number] = None,
+        regions: typing.Optional[typing.Sequence[builtins.str]] = None,
+        request_interval: typing.Optional[_Duration_4839e8c3] = None,
+        resource_path: typing.Optional[builtins.str] = None,
+        routing_control: typing.Optional[builtins.str] = None,
+        search_string: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''Properties for a new health check.
+
+        :param type: The type of health check to be associated with the record.
+        :param alarm_identifier: CloudWatch alarm that you want Amazon Route 53 health checkers to use to determine whether the specified health check is healthy. Default: - if the type is CLOUDWATCH_METRIC, this property is required. Otherwise, it is not configured.
+        :param child_health_checks: A list of health checks to monitor for this 'CALCULATED' health check. Default: - if the type is CALCULATED, this property is required. Otherwise, it is not configured.
+        :param enable_sni: Specify whether you want Amazon Route 53 to send the value of FullyQualifiedDomainName to the endpoint in the client_hello message during TLS negotiation. This allows the endpoint to respond to HTTPS health check requests with the applicable SSL/TLS certificate. Default: - if the type is HTTPS or HTTPS_STR_MATCH, this property default value is true. Otherwise, it is not configured.
+        :param failure_threshold: The number of consecutive health checks that an endpoint must pass or fail for Amazon Route 53 to change the current status of the endpoint from unhealthy to healthy or vice versa. Default: - if the type is CALCULATED it's not configured - if the type is CLOUDWATCH_METRIC it's not configured - otherwise, the default value is 3.
+        :param fqdn: Fully qualified domain name of the endpoint to be checked. Amazon Route 53 behavior depends on whether you specify a value for IPAddress. If you specify a value for IPAddress: Amazon Route 53 sends health check requests to the specified IPv4 or IPv6 address and passes the value of FullyQualifiedDomainName in the Host header for all health checks except TCP health checks. This is typically the fully qualified DNS name of the endpoint on which you want Route 53 to perform health checks. Note: If you specify a value for Port property other than 80 or 443, Route 53 will constract the value for Host header as FullyQualifiedDomainName:Port. If you don't specify a value for IPAddress: Route 53 sends a DNS request to the domain that you specify for FullyQualifiedDomainName at the interval that you specify for RequestInterval. Using an IPv4 address that DNS returns, Route 53 then checks the health of the endpoint. Additionally, if the type of the health check is HTTP, HTTPS, HTTP_STR_MATCH, or HTTPS_STR_MATCH, Route 53 passes the value of FullyQualifiedDomainName in the Host header, as it does when you specify value for IPAddress. If the type is TCP, Route 53 doesn't pass a Host header. Default: - not configured
+        :param health_threshold: The number of child health checks that are associated with a CALCULATED health that Amazon Route 53 must consider healthy for the CALCULATED health check to be considered healthy. Default: - if the type is CALCULATED, the default value is number of child health checks. Otherwise, it is not configured.
+        :param insufficient_data_health_status: The status of the health check when CloudWatch has insufficient data about the state of associated alarm. Default: - if the type is CLOUDWATCH_METRIC, the default value is InsufficientDataHealthStatus.LAST_KNOWN_STATUS. Otherwise, it is not configured.
+        :param inverted: Specify whether you want Amazon Route 53 to invert the status of a health check, so a health check that would normally be considered unhealthy is considered healthy, and vice versa. Default: false
+        :param ip_address: The IPv4 or IPv6 IP address for the endpoint that you want Amazon Route 53 to perform health checks on. If you don't specify a value for IPAddress, Route 53 sends a DNS request to resolve the domain name that you specify in FullyQualifiedDomainName at the interval that you specify in RequestInterval. Using an IPv4 address that DNS returns, Route 53 then checks the health of the endpoint. Default: - not configured
+        :param measure_latency: Specify whether you want Amazon Route 53 to measure the latency between health checkers in multiple AWS regions and your endpoint, and to display CloudWatch latency graphs on the Health Checks page in the Route 53 console. Default: - if the type is CALCULATED it's not configured - if the type is CLOUDWATCH_METRIC it's not configured - otherwise, the default value is false.
+        :param port: The port on the endpoint that you want Amazon Route 53 to perform health checks on. Default: - if the type is HTTP or HTTP_STR_MATCH, the default value is 80. - if the type is HTTPS or HTTPS_STR_MATCH, the default value is 443. - otherwise, it is not configured.
+        :param regions: An array of region identifiers that you want Amazon Route 53 health checkers to check the health of the endpoint from. Please refer to the CloudFormation documentation for the most up-to-date list of regions. Default: - if the type is CALCULATED, CLOUDWATCH_METRIC, or RECOVERY_CONTROL, this property is not configured. - otherwise, the default value will be set by CloudFormation itself and will include all valid regions. Please refer to the CloudFormation documentation for the most up-to-date list of regions.
+        :param request_interval: The duration between the time that Amazon Route 53 gets a response from your endpoint and the time that it sends the next health check request. Each Route 53 health checker makes requests at this interval. Default: - if the type is CALCULATED it's not configured - if the type is CLOUDWATCH_METRIC it's not configured - otherwise, the default value is 30 seconds.
+        :param resource_path: The path that you want Amazon Route 53 to request when performing health checks. The path can be any value for which your endpoint will return an HTTP status code of 2xx or 3xx when the endpoint is healthy, for example the file /docs/route53-health-check.html. Route 53 automatically adds the DNS name for the service and a leading forward slash (/) character. Default: - if the type is HTTP, HTTPS, HTTP_STR_MATCH, or HTTPS_STR_MATCH, the default value is empty string. - otherwise, it is not configured.
+        :param routing_control: The Amazon Resource Name (ARN) of the Route 53 Application Recovery Controller routing control that you want Amazon Route 53 health checkers to use to determine whether the specified health check is healthy. Default: - if the type is RECOVERY_CONTROL, this property is required. Otherwise, it is not configured.
+        :param search_string: The string that you want Amazon Route 53 to search for in the response body from the specified resource. If the string appears in the response body, Route 53 considers the resource healthy. Route 53 considers case when searching for SearchString in the response body. Default: - if the type is HTTP_STR_MATCH or HTTPS_STR_MATCH, this property is required. Otherwise, it is not configured.
+
+        :exampleMetadata: infused
+
+        Example::
+
+            # my_zone: route53.HostedZone
+            
+            
+            health_check = route53.HealthCheck(self, "HealthCheck",
+                type=route53.HealthCheckType.HTTP,
+                fqdn="example.com",
+                port=80,
+                resource_path="/health",
+                failure_threshold=3,
+                request_interval=Duration.seconds(30)
+            )
+            
+            route53.ARecord(self, "ARecord",
+                zone=my_zone,
+                target=route53.RecordTarget.from_ip_addresses("1.2.3.4"),
+                health_check=health_check,
+                weight=100
+            )
+            route53.ARecord(self, "ARecord2",
+                zone=my_zone,
+                target=route53.RecordTarget.from_ip_addresses("5.6.7.8"),
+                weight=0
+            )
+        '''
+        if isinstance(alarm_identifier, dict):
+            alarm_identifier = AlarmIdentifier(**alarm_identifier)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__aa97034136188f7866c26cd6fb12cf33983958b5147a7092dea7494be1142b56)
+            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
+            check_type(argname="argument alarm_identifier", value=alarm_identifier, expected_type=type_hints["alarm_identifier"])
+            check_type(argname="argument child_health_checks", value=child_health_checks, expected_type=type_hints["child_health_checks"])
+            check_type(argname="argument enable_sni", value=enable_sni, expected_type=type_hints["enable_sni"])
+            check_type(argname="argument failure_threshold", value=failure_threshold, expected_type=type_hints["failure_threshold"])
+            check_type(argname="argument fqdn", value=fqdn, expected_type=type_hints["fqdn"])
+            check_type(argname="argument health_threshold", value=health_threshold, expected_type=type_hints["health_threshold"])
+            check_type(argname="argument insufficient_data_health_status", value=insufficient_data_health_status, expected_type=type_hints["insufficient_data_health_status"])
+            check_type(argname="argument inverted", value=inverted, expected_type=type_hints["inverted"])
+            check_type(argname="argument ip_address", value=ip_address, expected_type=type_hints["ip_address"])
+            check_type(argname="argument measure_latency", value=measure_latency, expected_type=type_hints["measure_latency"])
+            check_type(argname="argument port", value=port, expected_type=type_hints["port"])
+            check_type(argname="argument regions", value=regions, expected_type=type_hints["regions"])
+            check_type(argname="argument request_interval", value=request_interval, expected_type=type_hints["request_interval"])
+            check_type(argname="argument resource_path", value=resource_path, expected_type=type_hints["resource_path"])
+            check_type(argname="argument routing_control", value=routing_control, expected_type=type_hints["routing_control"])
+            check_type(argname="argument search_string", value=search_string, expected_type=type_hints["search_string"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "type": type,
+        }
+        if alarm_identifier is not None:
+            self._values["alarm_identifier"] = alarm_identifier
+        if child_health_checks is not None:
+            self._values["child_health_checks"] = child_health_checks
+        if enable_sni is not None:
+            self._values["enable_sni"] = enable_sni
+        if failure_threshold is not None:
+            self._values["failure_threshold"] = failure_threshold
+        if fqdn is not None:
+            self._values["fqdn"] = fqdn
+        if health_threshold is not None:
+            self._values["health_threshold"] = health_threshold
+        if insufficient_data_health_status is not None:
+            self._values["insufficient_data_health_status"] = insufficient_data_health_status
+        if inverted is not None:
+            self._values["inverted"] = inverted
+        if ip_address is not None:
+            self._values["ip_address"] = ip_address
+        if measure_latency is not None:
+            self._values["measure_latency"] = measure_latency
+        if port is not None:
+            self._values["port"] = port
+        if regions is not None:
+            self._values["regions"] = regions
+        if request_interval is not None:
+            self._values["request_interval"] = request_interval
+        if resource_path is not None:
+            self._values["resource_path"] = resource_path
+        if routing_control is not None:
+            self._values["routing_control"] = routing_control
+        if search_string is not None:
+            self._values["search_string"] = search_string
+
+    @builtins.property
+    def type(self) -> "HealthCheckType":
+        '''The type of health check to be associated with the record.'''
+        result = self._values.get("type")
+        assert result is not None, "Required property 'type' is missing"
+        return typing.cast("HealthCheckType", result)
+
+    @builtins.property
+    def alarm_identifier(self) -> typing.Optional[AlarmIdentifier]:
+        '''CloudWatch alarm that you want Amazon Route 53 health checkers to use to determine whether the specified health check is healthy.
+
+        :default: - if the type is CLOUDWATCH_METRIC, this property is required. Otherwise, it is not configured.
+        '''
+        result = self._values.get("alarm_identifier")
+        return typing.cast(typing.Optional[AlarmIdentifier], result)
+
+    @builtins.property
+    def child_health_checks(self) -> typing.Optional[typing.List["IHealthCheck"]]:
+        '''A list of health checks to monitor for this 'CALCULATED' health check.
+
+        :default: - if the type is CALCULATED, this property is required. Otherwise, it is not configured.
+        '''
+        result = self._values.get("child_health_checks")
+        return typing.cast(typing.Optional[typing.List["IHealthCheck"]], result)
+
+    @builtins.property
+    def enable_sni(self) -> typing.Optional[builtins.bool]:
+        '''Specify whether you want Amazon Route 53 to send the value of FullyQualifiedDomainName to the endpoint in the client_hello message during TLS negotiation.
+
+        This allows the endpoint to respond to HTTPS health check requests with the applicable SSL/TLS certificate.
+
+        :default: - if the type is HTTPS or HTTPS_STR_MATCH, this property default value is true. Otherwise, it is not configured.
+        '''
+        result = self._values.get("enable_sni")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def failure_threshold(self) -> typing.Optional[jsii.Number]:
+        '''The number of consecutive health checks that an endpoint must pass or fail for Amazon Route 53 to change the current status of the endpoint from unhealthy to healthy or vice versa.
+
+        :default:
+
+        - if the type is CALCULATED it's not configured
+        - if the type is CLOUDWATCH_METRIC it's not configured
+        - otherwise, the default value is 3.
+        '''
+        result = self._values.get("failure_threshold")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def fqdn(self) -> typing.Optional[builtins.str]:
+        '''Fully qualified domain name of the endpoint to be checked.
+
+        Amazon Route 53 behavior depends on whether you specify a value for IPAddress.
+
+        If you specify a value for IPAddress:
+
+        Amazon Route 53 sends health check requests to the specified IPv4 or IPv6 address and passes the value of FullyQualifiedDomainName in the Host header for all health checks except TCP health checks. This is typically the fully qualified DNS name of the endpoint on which you want Route 53 to perform health checks.
+        Note: If you specify a value for Port property other than 80 or 443, Route 53 will constract the value for Host header as FullyQualifiedDomainName:Port.
+
+        If you don't specify a value for IPAddress:
+
+        Route 53 sends a DNS request to the domain that you specify for FullyQualifiedDomainName at the interval that you specify for RequestInterval. Using an IPv4 address that DNS returns, Route 53 then checks the health of the endpoint.
+
+        Additionally, if the type of the health check is HTTP, HTTPS, HTTP_STR_MATCH, or HTTPS_STR_MATCH, Route 53 passes the value of FullyQualifiedDomainName in the Host header, as it does when you specify value for IPAddress. If the type is TCP, Route 53 doesn't pass a Host header.
+
+        :default: - not configured
+        '''
+        result = self._values.get("fqdn")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def health_threshold(self) -> typing.Optional[jsii.Number]:
+        '''The number of child health checks that are associated with a CALCULATED health that Amazon Route 53 must consider healthy for the CALCULATED health check to be considered healthy.
+
+        :default: - if the type is CALCULATED, the default value is number of child health checks. Otherwise, it is not configured.
+        '''
+        result = self._values.get("health_threshold")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def insufficient_data_health_status(
+        self,
+    ) -> typing.Optional["InsufficientDataHealthStatusEnum"]:
+        '''The status of the health check when CloudWatch has insufficient data about the state of associated alarm.
+
+        :default: - if the type is CLOUDWATCH_METRIC, the default value is InsufficientDataHealthStatus.LAST_KNOWN_STATUS. Otherwise, it is not configured.
+        '''
+        result = self._values.get("insufficient_data_health_status")
+        return typing.cast(typing.Optional["InsufficientDataHealthStatusEnum"], result)
+
+    @builtins.property
+    def inverted(self) -> typing.Optional[builtins.bool]:
+        '''Specify whether you want Amazon Route 53 to invert the status of a health check, so a health check that would normally be considered unhealthy is considered healthy, and vice versa.
+
+        :default: false
+        '''
+        result = self._values.get("inverted")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def ip_address(self) -> typing.Optional[builtins.str]:
+        '''The IPv4 or IPv6 IP address for the endpoint that you want Amazon Route 53 to perform health checks on.
+
+        If you don't specify a value for IPAddress, Route 53 sends a DNS request to resolve the domain name that you specify in FullyQualifiedDomainName at the interval that you specify in RequestInterval. Using an IPv4 address that DNS returns, Route 53 then checks the health of the endpoint.
+
+        :default: - not configured
+        '''
+        result = self._values.get("ip_address")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def measure_latency(self) -> typing.Optional[builtins.bool]:
+        '''Specify whether you want Amazon Route 53 to measure the latency between health checkers in multiple AWS regions and your endpoint, and to display CloudWatch latency graphs on the Health Checks page in the Route 53 console.
+
+        :default:
+
+        - if the type is CALCULATED it's not configured
+        - if the type is CLOUDWATCH_METRIC it's not configured
+        - otherwise, the default value is false.
+        '''
+        result = self._values.get("measure_latency")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def port(self) -> typing.Optional[jsii.Number]:
+        '''The port on the endpoint that you want Amazon Route 53 to perform health checks on.
+
+        :default:
+
+        - if the type is HTTP or HTTP_STR_MATCH, the default value is 80.
+        - if the type is HTTPS or HTTPS_STR_MATCH, the default value is 443.
+        - otherwise, it is not configured.
+        '''
+        result = self._values.get("port")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def regions(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''An array of region identifiers that you want Amazon Route 53 health checkers to check the health of the endpoint from.
+
+        Please refer to the CloudFormation documentation for the most up-to-date list of regions.
+
+        :default:
+
+        - if the type is CALCULATED, CLOUDWATCH_METRIC, or RECOVERY_CONTROL, this property is not configured.
+        - otherwise, the default value will be set by CloudFormation itself and will include all valid regions. Please refer to the CloudFormation documentation for the most up-to-date list of regions.
+
+        :see: https://docs.aws.amazon.com/Route53/latest/APIReference/API_HealthCheckConfig.html
+        '''
+        result = self._values.get("regions")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+    @builtins.property
+    def request_interval(self) -> typing.Optional[_Duration_4839e8c3]:
+        '''The duration between the time that Amazon Route 53 gets a response from your endpoint and the time that it sends the next health check request.
+
+        Each Route 53 health checker makes requests at this interval.
+
+        :default:
+
+        - if the type is CALCULATED it's not configured
+        - if the type is CLOUDWATCH_METRIC it's not configured
+        - otherwise, the default value is 30 seconds.
+        '''
+        result = self._values.get("request_interval")
+        return typing.cast(typing.Optional[_Duration_4839e8c3], result)
+
+    @builtins.property
+    def resource_path(self) -> typing.Optional[builtins.str]:
+        '''The path that you want Amazon Route 53 to request when performing health checks.
+
+        The path can be any value for which your endpoint will return an HTTP status code of 2xx or 3xx when the endpoint is healthy, for example the file /docs/route53-health-check.html. Route 53 automatically adds the DNS name for the service and a leading forward slash (/) character.
+
+        :default:
+
+        - if the type is HTTP, HTTPS, HTTP_STR_MATCH, or HTTPS_STR_MATCH, the default value is empty string.
+        - otherwise, it is not configured.
+        '''
+        result = self._values.get("resource_path")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def routing_control(self) -> typing.Optional[builtins.str]:
+        '''The Amazon Resource Name (ARN) of the Route 53 Application Recovery Controller routing control that you want Amazon Route 53 health checkers to use to determine whether the specified health check is healthy.
+
+        :default: - if the type is RECOVERY_CONTROL, this property is required. Otherwise, it is not configured.
+        '''
+        result = self._values.get("routing_control")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def search_string(self) -> typing.Optional[builtins.str]:
+        '''The string that you want Amazon Route 53 to search for in the response body from the specified resource.
+
+        If the string appears in the response body, Route 53 considers the resource healthy.
+
+        Route 53 considers case when searching for SearchString in the response body.
+
+        :default: - if the type is HTTP_STR_MATCH or HTTPS_STR_MATCH, this property is required. Otherwise, it is not configured.
+        '''
+        result = self._values.get("search_string")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "HealthCheckProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.enum(jsii_type="aws-cdk-lib.aws_route53.HealthCheckType")
+class HealthCheckType(enum.Enum):
+    '''The type of health check to be associated with the record.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        # my_zone: route53.HostedZone
+        
+        
+        health_check = route53.HealthCheck(self, "HealthCheck",
+            type=route53.HealthCheckType.HTTP,
+            fqdn="example.com",
+            port=80,
+            resource_path="/health",
+            failure_threshold=3,
+            request_interval=Duration.seconds(30)
+        )
+        
+        route53.ARecord(self, "ARecord",
+            zone=my_zone,
+            target=route53.RecordTarget.from_ip_addresses("1.2.3.4"),
+            health_check=health_check,
+            weight=100
+        )
+        route53.ARecord(self, "ARecord2",
+            zone=my_zone,
+            target=route53.RecordTarget.from_ip_addresses("5.6.7.8"),
+            weight=0
+        )
+    '''
+
+    HTTP = "HTTP"
+    '''HTTP health check.
+
+    Route 53 tries to establish a TCP connection. If successful, Route 53 submits an HTTP request and waits for an HTTP status code of 200 or greater and less than 400.
+    '''
+    HTTPS = "HTTPS"
+    '''HTTPS health check.
+
+    Route 53 tries to establish a TCP connection. If successful, Route 53 submits an HTTPS request and waits for an HTTP status code of 200 or greater and less than 400.
+    '''
+    HTTP_STR_MATCH = "HTTP_STR_MATCH"
+    '''HTTP health check with string matching.
+
+    Route 53 tries to establish a TCP connection. If successful, Route 53 submits an HTTP request and searches the first 5,120 bytes of the response body for the string that you specify in SearchString.
+    '''
+    HTTPS_STR_MATCH = "HTTPS_STR_MATCH"
+    '''HTTPS health check with string matching.
+
+    Route 53 tries to establish a TCP connection. If successful, Route 53 submits an HTTPS request and searches the first 5,120 bytes of the response body for the string that you specify in SearchString.
+    '''
+    TCP = "TCP"
+    '''TCP health check.
+
+    Route 53 tries to establish a TCP connection.
+    '''
+    CLOUDWATCH_METRIC = "CLOUDWATCH_METRIC"
+    '''CloudWatch metric health check.
+
+    The health check is associated with a CloudWatch alarm. If the state of the alarm is OK, the health check is considered healthy. If the state is ALARM, the health check is considered unhealthy. If CloudWatch doesn't have sufficient data to determine whether the state is OK or ALARM, the health check status depends on the setting for InsufficientDataHealthStatus: Healthy, Unhealthy, or LastKnownStatus.
+    '''
+    CALCULATED = "CALCULATED"
+    '''Calculated health check.
+
+    For health checks that monitor the status of other health checks, Route 53 adds up the number of health checks that Route 53 health checkers consider to be healthy and compares that number with the value of HealthThreshold.
+    '''
+    RECOVERY_CONTROL = "RECOVERY_CONTROL"
+    '''Recovery control health check.
+
+    The health check is assocated with a Route53 Application Recovery Controller routing control. If the routing control state is ON, the health check is considered healthy. If the state is OFF, the health check is considered unhealthy.
+    '''
+
+
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_route53.HostedZoneAttributes",
     jsii_struct_bases=[],
@@ -6781,7 +7345,10 @@ class HostedZoneProviderProps:
             route53.ARecord(self, "AliasRecord",
                 zone=zone,
                 record_name=record_name,  # www
-                target=route53.RecordTarget.from_alias(targets.BucketWebsiteTarget(bucket_website))
+                target=route53.RecordTarget.from_alias(
+                    targets.BucketWebsiteTarget(bucket_website, {
+                        "evaluate_target_health": True
+                    }))
             )
         '''
         if __debug__:
@@ -6881,6 +7448,40 @@ class _IAliasRecordTargetProxy:
 typing.cast(typing.Any, IAliasRecordTarget).__jsii_proxy_class__ = lambda : _IAliasRecordTargetProxy
 
 
+@jsii.interface(jsii_type="aws-cdk-lib.aws_route53.IHealthCheck")
+class IHealthCheck(_IResource_c80c4260, typing_extensions.Protocol):
+    '''Imported or created health check.'''
+
+    @builtins.property
+    @jsii.member(jsii_name="healthCheckId")
+    def health_check_id(self) -> builtins.str:
+        '''The ID of the health check.
+
+        :attribute: true
+        '''
+        ...
+
+
+class _IHealthCheckProxy(
+    jsii.proxy_for(_IResource_c80c4260), # type: ignore[misc]
+):
+    '''Imported or created health check.'''
+
+    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_route53.IHealthCheck"
+
+    @builtins.property
+    @jsii.member(jsii_name="healthCheckId")
+    def health_check_id(self) -> builtins.str:
+        '''The ID of the health check.
+
+        :attribute: true
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "healthCheckId"))
+
+# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
+typing.cast(typing.Any, IHealthCheck).__jsii_proxy_class__ = lambda : _IHealthCheckProxy
+
+
 @jsii.interface(jsii_type="aws-cdk-lib.aws_route53.IHostedZone")
 class IHostedZone(_IResource_c80c4260, typing_extensions.Protocol):
     '''Imported or created hosted zone.'''
@@ -7122,6 +7723,18 @@ class _IRecordSetProxy(
 typing.cast(typing.Any, IRecordSet).__jsii_proxy_class__ = lambda : _IRecordSetProxy
 
 
+@jsii.enum(jsii_type="aws-cdk-lib.aws_route53.InsufficientDataHealthStatusEnum")
+class InsufficientDataHealthStatusEnum(enum.Enum):
+    '''The status of the health check when CloudWatch has insufficient data about the state of associated alarm.'''
+
+    HEALTHY = "HEALTHY"
+    '''Route 53 health check status will be healthy.'''
+    UNHEALTHY = "UNHEALTHY"
+    '''Route 53 health check status will be unhealthy.'''
+    LAST_KNOWN_STATUS = "LAST_KNOWN_STATUS"
+    '''Route 53 health check status will be the status of the health check before Route 53 had insufficient data.'''
+
+
 @jsii.implements(IKeySigningKey)
 class KeySigningKey(
     _Resource_45bc6135,
@@ -7896,6 +8509,7 @@ class RecordSet(
         from aws_cdk import aws_route53 as route53
         
         # geo_location: route53.GeoLocation
+        # health_check: route53.HealthCheck
         # hosted_zone: route53.HostedZone
         # record_target: route53.RecordTarget
         
@@ -7908,6 +8522,7 @@ class RecordSet(
             comment="comment",
             delete_existing=False,
             geo_location=geo_location,
+            health_check=health_check,
             multi_value_answer=False,
             record_name="recordName",
             region="region",
@@ -7928,6 +8543,7 @@ class RecordSet(
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -7944,6 +8560,7 @@ class RecordSet(
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -7962,6 +8579,7 @@ class RecordSet(
             comment=comment,
             delete_existing=delete_existing,
             geo_location=geo_location,
+            health_check=health_check,
             multi_value_answer=multi_value_answer,
             record_name=record_name,
             region=region,
@@ -7987,6 +8605,7 @@ class RecordSet(
         "comment": "comment",
         "delete_existing": "deleteExisting",
         "geo_location": "geoLocation",
+        "health_check": "healthCheck",
         "multi_value_answer": "multiValueAnswer",
         "record_name": "recordName",
         "region": "region",
@@ -8003,6 +8622,7 @@ class RecordSetOptions:
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -8016,6 +8636,7 @@ class RecordSetOptions:
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -8033,6 +8654,7 @@ class RecordSetOptions:
             from aws_cdk import aws_route53 as route53
             
             # geo_location: route53.GeoLocation
+            # health_check: route53.HealthCheck
             # hosted_zone: route53.HostedZone
             
             record_set_options = route53.RecordSetOptions(
@@ -8042,6 +8664,7 @@ class RecordSetOptions:
                 comment="comment",
                 delete_existing=False,
                 geo_location=geo_location,
+                health_check=health_check,
                 multi_value_answer=False,
                 record_name="recordName",
                 region="region",
@@ -8056,6 +8679,7 @@ class RecordSetOptions:
             check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
             check_type(argname="argument delete_existing", value=delete_existing, expected_type=type_hints["delete_existing"])
             check_type(argname="argument geo_location", value=geo_location, expected_type=type_hints["geo_location"])
+            check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
             check_type(argname="argument multi_value_answer", value=multi_value_answer, expected_type=type_hints["multi_value_answer"])
             check_type(argname="argument record_name", value=record_name, expected_type=type_hints["record_name"])
             check_type(argname="argument region", value=region, expected_type=type_hints["region"])
@@ -8071,6 +8695,8 @@ class RecordSetOptions:
             self._values["delete_existing"] = delete_existing
         if geo_location is not None:
             self._values["geo_location"] = geo_location
+        if health_check is not None:
+            self._values["health_check"] = health_check
         if multi_value_answer is not None:
             self._values["multi_value_answer"] = multi_value_answer
         if record_name is not None:
@@ -8125,6 +8751,17 @@ class RecordSetOptions:
         result = self._values.get("geo_location")
         return typing.cast(typing.Optional[GeoLocation], result)
 
+    @builtins.property
+    def health_check(self) -> typing.Optional[IHealthCheck]:
+        '''The health check to associate with the record set.
+
+        Route53 will return this record set in response to DNS queries only if the health check is passing.
+
+        :default: - No health check configured
+        '''
+        result = self._values.get("health_check")
+        return typing.cast(typing.Optional[IHealthCheck], result)
+
     @builtins.property
     def multi_value_answer(self) -> typing.Optional[builtins.bool]:
         '''Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries.
@@ -8225,6 +8862,7 @@ class RecordSetOptions:
         "comment": "comment",
         "delete_existing": "deleteExisting",
         "geo_location": "geoLocation",
+        "health_check": "healthCheck",
         "multi_value_answer": "multiValueAnswer",
         "record_name": "recordName",
         "region": "region",
@@ -8243,6 +8881,7 @@ class RecordSetProps(RecordSetOptions):
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -8258,6 +8897,7 @@ class RecordSetProps(RecordSetOptions):
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -8277,6 +8917,7 @@ class RecordSetProps(RecordSetOptions):
             from aws_cdk import aws_route53 as route53
             
             # geo_location: route53.GeoLocation
+            # health_check: route53.HealthCheck
             # hosted_zone: route53.HostedZone
             # record_target: route53.RecordTarget
             
@@ -8289,6 +8930,7 @@ class RecordSetProps(RecordSetOptions):
                 comment="comment",
                 delete_existing=False,
                 geo_location=geo_location,
+                health_check=health_check,
                 multi_value_answer=False,
                 record_name="recordName",
                 region="region",
@@ -8303,6 +8945,7 @@ class RecordSetProps(RecordSetOptions):
             check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
             check_type(argname="argument delete_existing", value=delete_existing, expected_type=type_hints["delete_existing"])
             check_type(argname="argument geo_location", value=geo_location, expected_type=type_hints["geo_location"])
+            check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
             check_type(argname="argument multi_value_answer", value=multi_value_answer, expected_type=type_hints["multi_value_answer"])
             check_type(argname="argument record_name", value=record_name, expected_type=type_hints["record_name"])
             check_type(argname="argument region", value=region, expected_type=type_hints["region"])
@@ -8322,6 +8965,8 @@ class RecordSetProps(RecordSetOptions):
             self._values["delete_existing"] = delete_existing
         if geo_location is not None:
             self._values["geo_location"] = geo_location
+        if health_check is not None:
+            self._values["health_check"] = health_check
         if multi_value_answer is not None:
             self._values["multi_value_answer"] = multi_value_answer
         if record_name is not None:
@@ -8376,6 +9021,17 @@ class RecordSetProps(RecordSetOptions):
         result = self._values.get("geo_location")
         return typing.cast(typing.Optional[GeoLocation], result)
 
+    @builtins.property
+    def health_check(self) -> typing.Optional[IHealthCheck]:
+        '''The health check to associate with the record set.
+
+        Route53 will return this record set in response to DNS queries only if the health check is passing.
+
+        :default: - No health check configured
+        '''
+        result = self._values.get("health_check")
+        return typing.cast(typing.Optional[IHealthCheck], result)
+
     @builtins.property
     def multi_value_answer(self) -> typing.Optional[builtins.bool]:
         '''Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries.
@@ -8691,6 +9347,7 @@ class SrvRecord(
         from aws_cdk import aws_route53 as route53
         
         # geo_location: route53.GeoLocation
+        # health_check: route53.HealthCheck
         # hosted_zone: route53.HostedZone
         
         srv_record = route53.SrvRecord(self, "MySrvRecord",
@@ -8706,6 +9363,7 @@ class SrvRecord(
             comment="comment",
             delete_existing=False,
             geo_location=geo_location,
+            health_check=health_check,
             multi_value_answer=False,
             record_name="recordName",
             region="region",
@@ -8725,6 +9383,7 @@ class SrvRecord(
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -8740,6 +9399,7 @@ class SrvRecord(
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -8757,6 +9417,7 @@ class SrvRecord(
             comment=comment,
             delete_existing=delete_existing,
             geo_location=geo_location,
+            health_check=health_check,
             multi_value_answer=multi_value_answer,
             record_name=record_name,
             region=region,
@@ -8776,6 +9437,7 @@ class SrvRecord(
         "comment": "comment",
         "delete_existing": "deleteExisting",
         "geo_location": "geoLocation",
+        "health_check": "healthCheck",
         "multi_value_answer": "multiValueAnswer",
         "record_name": "recordName",
         "region": "region",
@@ -8793,6 +9455,7 @@ class SrvRecordProps(RecordSetOptions):
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -8807,6 +9470,7 @@ class SrvRecordProps(RecordSetOptions):
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -8825,6 +9489,7 @@ class SrvRecordProps(RecordSetOptions):
             from aws_cdk import aws_route53 as route53
             
             # geo_location: route53.GeoLocation
+            # health_check: route53.HealthCheck
             # hosted_zone: route53.HostedZone
             
             srv_record_props = route53.SrvRecordProps(
@@ -8840,6 +9505,7 @@ class SrvRecordProps(RecordSetOptions):
                 comment="comment",
                 delete_existing=False,
                 geo_location=geo_location,
+                health_check=health_check,
                 multi_value_answer=False,
                 record_name="recordName",
                 region="region",
@@ -8854,6 +9520,7 @@ class SrvRecordProps(RecordSetOptions):
             check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
             check_type(argname="argument delete_existing", value=delete_existing, expected_type=type_hints["delete_existing"])
             check_type(argname="argument geo_location", value=geo_location, expected_type=type_hints["geo_location"])
+            check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
             check_type(argname="argument multi_value_answer", value=multi_value_answer, expected_type=type_hints["multi_value_answer"])
             check_type(argname="argument record_name", value=record_name, expected_type=type_hints["record_name"])
             check_type(argname="argument region", value=region, expected_type=type_hints["region"])
@@ -8871,6 +9538,8 @@ class SrvRecordProps(RecordSetOptions):
             self._values["delete_existing"] = delete_existing
         if geo_location is not None:
             self._values["geo_location"] = geo_location
+        if health_check is not None:
+            self._values["health_check"] = health_check
         if multi_value_answer is not None:
             self._values["multi_value_answer"] = multi_value_answer
         if record_name is not None:
@@ -8925,6 +9594,17 @@ class SrvRecordProps(RecordSetOptions):
         result = self._values.get("geo_location")
         return typing.cast(typing.Optional[GeoLocation], result)
 
+    @builtins.property
+    def health_check(self) -> typing.Optional[IHealthCheck]:
+        '''The health check to associate with the record set.
+
+        Route53 will return this record set in response to DNS queries only if the health check is passing.
+
+        :default: - No health check configured
+        '''
+        result = self._values.get("health_check")
+        return typing.cast(typing.Optional[IHealthCheck], result)
+
     @builtins.property
     def multi_value_answer(self) -> typing.Optional[builtins.bool]:
         '''Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries.
@@ -9154,6 +9834,7 @@ class TxtRecord(
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -9169,6 +9850,7 @@ class TxtRecord(
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -9186,6 +9868,7 @@ class TxtRecord(
             comment=comment,
             delete_existing=delete_existing,
             geo_location=geo_location,
+            health_check=health_check,
             multi_value_answer=multi_value_answer,
             record_name=record_name,
             region=region,
@@ -9205,6 +9888,7 @@ class TxtRecord(
         "comment": "comment",
         "delete_existing": "deleteExisting",
         "geo_location": "geoLocation",
+        "health_check": "healthCheck",
         "multi_value_answer": "multiValueAnswer",
         "record_name": "recordName",
         "region": "region",
@@ -9222,6 +9906,7 @@ class TxtRecordProps(RecordSetOptions):
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -9236,6 +9921,7 @@ class TxtRecordProps(RecordSetOptions):
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -9267,6 +9953,7 @@ class TxtRecordProps(RecordSetOptions):
             check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
             check_type(argname="argument delete_existing", value=delete_existing, expected_type=type_hints["delete_existing"])
             check_type(argname="argument geo_location", value=geo_location, expected_type=type_hints["geo_location"])
+            check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
             check_type(argname="argument multi_value_answer", value=multi_value_answer, expected_type=type_hints["multi_value_answer"])
             check_type(argname="argument record_name", value=record_name, expected_type=type_hints["record_name"])
             check_type(argname="argument region", value=region, expected_type=type_hints["region"])
@@ -9284,6 +9971,8 @@ class TxtRecordProps(RecordSetOptions):
             self._values["delete_existing"] = delete_existing
         if geo_location is not None:
             self._values["geo_location"] = geo_location
+        if health_check is not None:
+            self._values["health_check"] = health_check
         if multi_value_answer is not None:
             self._values["multi_value_answer"] = multi_value_answer
         if record_name is not None:
@@ -9338,6 +10027,17 @@ class TxtRecordProps(RecordSetOptions):
         result = self._values.get("geo_location")
         return typing.cast(typing.Optional[GeoLocation], result)
 
+    @builtins.property
+    def health_check(self) -> typing.Optional[IHealthCheck]:
+        '''The health check to associate with the record set.
+
+        Route53 will return this record set in response to DNS queries only if the health check is passing.
+
+        :default: - No health check configured
+        '''
+        result = self._values.get("health_check")
+        return typing.cast(typing.Optional[IHealthCheck], result)
+
     @builtins.property
     def multi_value_answer(self) -> typing.Optional[builtins.bool]:
         '''Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries.
@@ -9679,6 +10379,7 @@ class ZoneDelegationRecord(
         from aws_cdk import aws_route53 as route53
         
         # geo_location: route53.GeoLocation
+        # health_check: route53.HealthCheck
         # hosted_zone: route53.HostedZone
         
         zone_delegation_record = route53.ZoneDelegationRecord(self, "MyZoneDelegationRecord",
@@ -9689,6 +10390,7 @@ class ZoneDelegationRecord(
             comment="comment",
             delete_existing=False,
             geo_location=geo_location,
+            health_check=health_check,
             multi_value_answer=False,
             record_name="recordName",
             region="region",
@@ -9708,6 +10410,7 @@ class ZoneDelegationRecord(
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -9723,6 +10426,7 @@ class ZoneDelegationRecord(
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -9740,6 +10444,7 @@ class ZoneDelegationRecord(
             comment=comment,
             delete_existing=delete_existing,
             geo_location=geo_location,
+            health_check=health_check,
             multi_value_answer=multi_value_answer,
             record_name=record_name,
             region=region,
@@ -9759,6 +10464,7 @@ class ZoneDelegationRecord(
         "comment": "comment",
         "delete_existing": "deleteExisting",
         "geo_location": "geoLocation",
+        "health_check": "healthCheck",
         "multi_value_answer": "multiValueAnswer",
         "record_name": "recordName",
         "region": "region",
@@ -9776,6 +10482,7 @@ class ZoneDelegationRecordProps(RecordSetOptions):
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -9790,6 +10497,7 @@ class ZoneDelegationRecordProps(RecordSetOptions):
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -9808,6 +10516,7 @@ class ZoneDelegationRecordProps(RecordSetOptions):
             from aws_cdk import aws_route53 as route53
             
             # geo_location: route53.GeoLocation
+            # health_check: route53.HealthCheck
             # hosted_zone: route53.HostedZone
             
             zone_delegation_record_props = route53.ZoneDelegationRecordProps(
@@ -9818,6 +10527,7 @@ class ZoneDelegationRecordProps(RecordSetOptions):
                 comment="comment",
                 delete_existing=False,
                 geo_location=geo_location,
+                health_check=health_check,
                 multi_value_answer=False,
                 record_name="recordName",
                 region="region",
@@ -9832,6 +10542,7 @@ class ZoneDelegationRecordProps(RecordSetOptions):
             check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
             check_type(argname="argument delete_existing", value=delete_existing, expected_type=type_hints["delete_existing"])
             check_type(argname="argument geo_location", value=geo_location, expected_type=type_hints["geo_location"])
+            check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
             check_type(argname="argument multi_value_answer", value=multi_value_answer, expected_type=type_hints["multi_value_answer"])
             check_type(argname="argument record_name", value=record_name, expected_type=type_hints["record_name"])
             check_type(argname="argument region", value=region, expected_type=type_hints["region"])
@@ -9849,6 +10560,8 @@ class ZoneDelegationRecordProps(RecordSetOptions):
             self._values["delete_existing"] = delete_existing
         if geo_location is not None:
             self._values["geo_location"] = geo_location
+        if health_check is not None:
+            self._values["health_check"] = health_check
         if multi_value_answer is not None:
             self._values["multi_value_answer"] = multi_value_answer
         if record_name is not None:
@@ -9903,6 +10616,17 @@ class ZoneDelegationRecordProps(RecordSetOptions):
         result = self._values.get("geo_location")
         return typing.cast(typing.Optional[GeoLocation], result)
 
+    @builtins.property
+    def health_check(self) -> typing.Optional[IHealthCheck]:
+        '''The health check to associate with the record set.
+
+        Route53 will return this record set in response to DNS queries only if the health check is passing.
+
+        :default: - No health check configured
+        '''
+        result = self._values.get("health_check")
+        return typing.cast(typing.Optional[IHealthCheck], result)
+
     @builtins.property
     def multi_value_answer(self) -> typing.Optional[builtins.bool]:
         '''Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries.
@@ -10091,15 +10815,18 @@ class ARecord(
 
     Example::
 
-        import aws_cdk.aws_apigateway as apigw
+        import aws_cdk.aws_elasticloadbalancingv2 as elbv2
         
         # zone: route53.HostedZone
-        # rest_api: apigw.LambdaRestApi
+        # lb: elbv2.ApplicationLoadBalancer
         
         
         route53.ARecord(self, "AliasRecord",
             zone=zone,
-            target=route53.RecordTarget.from_alias(targets.ApiGateway(rest_api))
+            target=route53.RecordTarget.from_alias(
+                targets.LoadBalancerTarget(lb, {
+                    "evaluate_target_health": True
+                }))
         )
     '''
 
@@ -10113,6 +10840,7 @@ class ARecord(
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -10128,6 +10856,7 @@ class ARecord(
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -10145,6 +10874,7 @@ class ARecord(
             comment=comment,
             delete_existing=delete_existing,
             geo_location=geo_location,
+            health_check=health_check,
             multi_value_answer=multi_value_answer,
             record_name=record_name,
             region=region,
@@ -10167,6 +10897,7 @@ class ARecord(
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -10186,6 +10917,7 @@ class ARecord(
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -10207,6 +10939,7 @@ class ARecord(
             comment=comment,
             delete_existing=delete_existing,
             geo_location=geo_location,
+            health_check=health_check,
             multi_value_answer=multi_value_answer,
             record_name=record_name,
             region=region,
@@ -10226,6 +10959,7 @@ class ARecord(
         "comment": "comment",
         "delete_existing": "deleteExisting",
         "geo_location": "geoLocation",
+        "health_check": "healthCheck",
         "multi_value_answer": "multiValueAnswer",
         "record_name": "recordName",
         "region": "region",
@@ -10243,6 +10977,7 @@ class ARecordAttrs(RecordSetOptions):
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -10257,6 +10992,7 @@ class ARecordAttrs(RecordSetOptions):
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -10285,6 +11021,7 @@ class ARecordAttrs(RecordSetOptions):
             check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
             check_type(argname="argument delete_existing", value=delete_existing, expected_type=type_hints["delete_existing"])
             check_type(argname="argument geo_location", value=geo_location, expected_type=type_hints["geo_location"])
+            check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
             check_type(argname="argument multi_value_answer", value=multi_value_answer, expected_type=type_hints["multi_value_answer"])
             check_type(argname="argument record_name", value=record_name, expected_type=type_hints["record_name"])
             check_type(argname="argument region", value=region, expected_type=type_hints["region"])
@@ -10302,6 +11039,8 @@ class ARecordAttrs(RecordSetOptions):
             self._values["delete_existing"] = delete_existing
         if geo_location is not None:
             self._values["geo_location"] = geo_location
+        if health_check is not None:
+            self._values["health_check"] = health_check
         if multi_value_answer is not None:
             self._values["multi_value_answer"] = multi_value_answer
         if record_name is not None:
@@ -10356,6 +11095,17 @@ class ARecordAttrs(RecordSetOptions):
         result = self._values.get("geo_location")
         return typing.cast(typing.Optional[GeoLocation], result)
 
+    @builtins.property
+    def health_check(self) -> typing.Optional[IHealthCheck]:
+        '''The health check to associate with the record set.
+
+        Route53 will return this record set in response to DNS queries only if the health check is passing.
+
+        :default: - No health check configured
+        '''
+        result = self._values.get("health_check")
+        return typing.cast(typing.Optional[IHealthCheck], result)
+
     @builtins.property
     def multi_value_answer(self) -> typing.Optional[builtins.bool]:
         '''Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries.
@@ -10463,6 +11213,7 @@ class ARecordAttrs(RecordSetOptions):
         "comment": "comment",
         "delete_existing": "deleteExisting",
         "geo_location": "geoLocation",
+        "health_check": "healthCheck",
         "multi_value_answer": "multiValueAnswer",
         "record_name": "recordName",
         "region": "region",
@@ -10480,6 +11231,7 @@ class ARecordProps(RecordSetOptions):
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -10494,6 +11246,7 @@ class ARecordProps(RecordSetOptions):
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -10506,15 +11259,18 @@ class ARecordProps(RecordSetOptions):
 
         Example::
 
-            import aws_cdk.aws_apigateway as apigw
+            import aws_cdk.aws_elasticloadbalancingv2 as elbv2
             
             # zone: route53.HostedZone
-            # rest_api: apigw.LambdaRestApi
+            # lb: elbv2.ApplicationLoadBalancer
             
             
             route53.ARecord(self, "AliasRecord",
                 zone=zone,
-                target=route53.RecordTarget.from_alias(targets.ApiGateway(rest_api))
+                target=route53.RecordTarget.from_alias(
+                    targets.LoadBalancerTarget(lb, {
+                        "evaluate_target_health": True
+                    }))
             )
         '''
         if __debug__:
@@ -10523,6 +11279,7 @@ class ARecordProps(RecordSetOptions):
             check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
             check_type(argname="argument delete_existing", value=delete_existing, expected_type=type_hints["delete_existing"])
             check_type(argname="argument geo_location", value=geo_location, expected_type=type_hints["geo_location"])
+            check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
             check_type(argname="argument multi_value_answer", value=multi_value_answer, expected_type=type_hints["multi_value_answer"])
             check_type(argname="argument record_name", value=record_name, expected_type=type_hints["record_name"])
             check_type(argname="argument region", value=region, expected_type=type_hints["region"])
@@ -10540,6 +11297,8 @@ class ARecordProps(RecordSetOptions):
             self._values["delete_existing"] = delete_existing
         if geo_location is not None:
             self._values["geo_location"] = geo_location
+        if health_check is not None:
+            self._values["health_check"] = health_check
         if multi_value_answer is not None:
             self._values["multi_value_answer"] = multi_value_answer
         if record_name is not None:
@@ -10594,6 +11353,17 @@ class ARecordProps(RecordSetOptions):
         result = self._values.get("geo_location")
         return typing.cast(typing.Optional[GeoLocation], result)
 
+    @builtins.property
+    def health_check(self) -> typing.Optional[IHealthCheck]:
+        '''The health check to associate with the record set.
+
+        Route53 will return this record set in response to DNS queries only if the health check is passing.
+
+        :default: - No health check configured
+        '''
+        result = self._values.get("health_check")
+        return typing.cast(typing.Optional[IHealthCheck], result)
+
     @builtins.property
     def multi_value_answer(self) -> typing.Optional[builtins.bool]:
         '''Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries.
@@ -10726,6 +11496,7 @@ class AaaaRecord(
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -10741,6 +11512,7 @@ class AaaaRecord(
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -10758,6 +11530,7 @@ class AaaaRecord(
             comment=comment,
             delete_existing=delete_existing,
             geo_location=geo_location,
+            health_check=health_check,
             multi_value_answer=multi_value_answer,
             record_name=record_name,
             region=region,
@@ -10777,6 +11550,7 @@ class AaaaRecord(
         "comment": "comment",
         "delete_existing": "deleteExisting",
         "geo_location": "geoLocation",
+        "health_check": "healthCheck",
         "multi_value_answer": "multiValueAnswer",
         "record_name": "recordName",
         "region": "region",
@@ -10794,6 +11568,7 @@ class AaaaRecordProps(RecordSetOptions):
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -10808,6 +11583,7 @@ class AaaaRecordProps(RecordSetOptions):
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -10836,6 +11612,7 @@ class AaaaRecordProps(RecordSetOptions):
             check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
             check_type(argname="argument delete_existing", value=delete_existing, expected_type=type_hints["delete_existing"])
             check_type(argname="argument geo_location", value=geo_location, expected_type=type_hints["geo_location"])
+            check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
             check_type(argname="argument multi_value_answer", value=multi_value_answer, expected_type=type_hints["multi_value_answer"])
             check_type(argname="argument record_name", value=record_name, expected_type=type_hints["record_name"])
             check_type(argname="argument region", value=region, expected_type=type_hints["region"])
@@ -10853,6 +11630,8 @@ class AaaaRecordProps(RecordSetOptions):
             self._values["delete_existing"] = delete_existing
         if geo_location is not None:
             self._values["geo_location"] = geo_location
+        if health_check is not None:
+            self._values["health_check"] = health_check
         if multi_value_answer is not None:
             self._values["multi_value_answer"] = multi_value_answer
         if record_name is not None:
@@ -10907,6 +11686,17 @@ class AaaaRecordProps(RecordSetOptions):
         result = self._values.get("geo_location")
         return typing.cast(typing.Optional[GeoLocation], result)
 
+    @builtins.property
+    def health_check(self) -> typing.Optional[IHealthCheck]:
+        '''The health check to associate with the record set.
+
+        Route53 will return this record set in response to DNS queries only if the health check is passing.
+
+        :default: - No health check configured
+        '''
+        result = self._values.get("health_check")
+        return typing.cast(typing.Optional[IHealthCheck], result)
+
     @builtins.property
     def multi_value_answer(self) -> typing.Optional[builtins.bool]:
         '''Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries.
@@ -11014,6 +11804,7 @@ class AaaaRecordProps(RecordSetOptions):
         "comment": "comment",
         "delete_existing": "deleteExisting",
         "geo_location": "geoLocation",
+        "health_check": "healthCheck",
         "multi_value_answer": "multiValueAnswer",
         "record_name": "recordName",
         "region": "region",
@@ -11030,6 +11821,7 @@ class CaaAmazonRecordProps(RecordSetOptions):
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -11043,6 +11835,7 @@ class CaaAmazonRecordProps(RecordSetOptions):
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -11060,6 +11853,7 @@ class CaaAmazonRecordProps(RecordSetOptions):
             from aws_cdk import aws_route53 as route53
             
             # geo_location: route53.GeoLocation
+            # health_check: route53.HealthCheck
             # hosted_zone: route53.HostedZone
             
             caa_amazon_record_props = route53.CaaAmazonRecordProps(
@@ -11069,6 +11863,7 @@ class CaaAmazonRecordProps(RecordSetOptions):
                 comment="comment",
                 delete_existing=False,
                 geo_location=geo_location,
+                health_check=health_check,
                 multi_value_answer=False,
                 record_name="recordName",
                 region="region",
@@ -11083,6 +11878,7 @@ class CaaAmazonRecordProps(RecordSetOptions):
             check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
             check_type(argname="argument delete_existing", value=delete_existing, expected_type=type_hints["delete_existing"])
             check_type(argname="argument geo_location", value=geo_location, expected_type=type_hints["geo_location"])
+            check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
             check_type(argname="argument multi_value_answer", value=multi_value_answer, expected_type=type_hints["multi_value_answer"])
             check_type(argname="argument record_name", value=record_name, expected_type=type_hints["record_name"])
             check_type(argname="argument region", value=region, expected_type=type_hints["region"])
@@ -11098,6 +11894,8 @@ class CaaAmazonRecordProps(RecordSetOptions):
             self._values["delete_existing"] = delete_existing
         if geo_location is not None:
             self._values["geo_location"] = geo_location
+        if health_check is not None:
+            self._values["health_check"] = health_check
         if multi_value_answer is not None:
             self._values["multi_value_answer"] = multi_value_answer
         if record_name is not None:
@@ -11152,6 +11950,17 @@ class CaaAmazonRecordProps(RecordSetOptions):
         result = self._values.get("geo_location")
         return typing.cast(typing.Optional[GeoLocation], result)
 
+    @builtins.property
+    def health_check(self) -> typing.Optional[IHealthCheck]:
+        '''The health check to associate with the record set.
+
+        Route53 will return this record set in response to DNS queries only if the health check is passing.
+
+        :default: - No health check configured
+        '''
+        result = self._values.get("health_check")
+        return typing.cast(typing.Optional[IHealthCheck], result)
+
     @builtins.property
     def multi_value_answer(self) -> typing.Optional[builtins.bool]:
         '''Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries.
@@ -11262,6 +12071,7 @@ class CaaRecord(
         from aws_cdk import aws_route53 as route53
         
         # geo_location: route53.GeoLocation
+        # health_check: route53.HealthCheck
         # hosted_zone: route53.HostedZone
         
         caa_record = route53.CaaRecord(self, "MyCaaRecord",
@@ -11276,6 +12086,7 @@ class CaaRecord(
             comment="comment",
             delete_existing=False,
             geo_location=geo_location,
+            health_check=health_check,
             multi_value_answer=False,
             record_name="recordName",
             region="region",
@@ -11295,6 +12106,7 @@ class CaaRecord(
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -11310,6 +12122,7 @@ class CaaRecord(
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -11327,6 +12140,7 @@ class CaaRecord(
             comment=comment,
             delete_existing=delete_existing,
             geo_location=geo_location,
+            health_check=health_check,
             multi_value_answer=multi_value_answer,
             record_name=record_name,
             region=region,
@@ -11346,6 +12160,7 @@ class CaaRecord(
         "comment": "comment",
         "delete_existing": "deleteExisting",
         "geo_location": "geoLocation",
+        "health_check": "healthCheck",
         "multi_value_answer": "multiValueAnswer",
         "record_name": "recordName",
         "region": "region",
@@ -11363,6 +12178,7 @@ class CaaRecordProps(RecordSetOptions):
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -11377,6 +12193,7 @@ class CaaRecordProps(RecordSetOptions):
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -11395,6 +12212,7 @@ class CaaRecordProps(RecordSetOptions):
             from aws_cdk import aws_route53 as route53
             
             # geo_location: route53.GeoLocation
+            # health_check: route53.HealthCheck
             # hosted_zone: route53.HostedZone
             
             caa_record_props = route53.CaaRecordProps(
@@ -11409,6 +12227,7 @@ class CaaRecordProps(RecordSetOptions):
                 comment="comment",
                 delete_existing=False,
                 geo_location=geo_location,
+                health_check=health_check,
                 multi_value_answer=False,
                 record_name="recordName",
                 region="region",
@@ -11423,6 +12242,7 @@ class CaaRecordProps(RecordSetOptions):
             check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
             check_type(argname="argument delete_existing", value=delete_existing, expected_type=type_hints["delete_existing"])
             check_type(argname="argument geo_location", value=geo_location, expected_type=type_hints["geo_location"])
+            check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
             check_type(argname="argument multi_value_answer", value=multi_value_answer, expected_type=type_hints["multi_value_answer"])
             check_type(argname="argument record_name", value=record_name, expected_type=type_hints["record_name"])
             check_type(argname="argument region", value=region, expected_type=type_hints["region"])
@@ -11440,6 +12260,8 @@ class CaaRecordProps(RecordSetOptions):
             self._values["delete_existing"] = delete_existing
         if geo_location is not None:
             self._values["geo_location"] = geo_location
+        if health_check is not None:
+            self._values["health_check"] = health_check
         if multi_value_answer is not None:
             self._values["multi_value_answer"] = multi_value_answer
         if record_name is not None:
@@ -11494,6 +12316,17 @@ class CaaRecordProps(RecordSetOptions):
         result = self._values.get("geo_location")
         return typing.cast(typing.Optional[GeoLocation], result)
 
+    @builtins.property
+    def health_check(self) -> typing.Optional[IHealthCheck]:
+        '''The health check to associate with the record set.
+
+        Route53 will return this record set in response to DNS queries only if the health check is passing.
+
+        :default: - No health check configured
+        '''
+        result = self._values.get("health_check")
+        return typing.cast(typing.Optional[IHealthCheck], result)
+
     @builtins.property
     def multi_value_answer(self) -> typing.Optional[builtins.bool]:
         '''Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries.
@@ -11649,6 +12482,7 @@ class CnameRecord(
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -11664,6 +12498,7 @@ class CnameRecord(
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -11681,6 +12516,7 @@ class CnameRecord(
             comment=comment,
             delete_existing=delete_existing,
             geo_location=geo_location,
+            health_check=health_check,
             multi_value_answer=multi_value_answer,
             record_name=record_name,
             region=region,
@@ -11700,6 +12536,7 @@ class CnameRecord(
         "comment": "comment",
         "delete_existing": "deleteExisting",
         "geo_location": "geoLocation",
+        "health_check": "healthCheck",
         "multi_value_answer": "multiValueAnswer",
         "record_name": "recordName",
         "region": "region",
@@ -11717,6 +12554,7 @@ class CnameRecordProps(RecordSetOptions):
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -11731,6 +12569,7 @@ class CnameRecordProps(RecordSetOptions):
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -11782,6 +12621,7 @@ class CnameRecordProps(RecordSetOptions):
             check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
             check_type(argname="argument delete_existing", value=delete_existing, expected_type=type_hints["delete_existing"])
             check_type(argname="argument geo_location", value=geo_location, expected_type=type_hints["geo_location"])
+            check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
             check_type(argname="argument multi_value_answer", value=multi_value_answer, expected_type=type_hints["multi_value_answer"])
             check_type(argname="argument record_name", value=record_name, expected_type=type_hints["record_name"])
             check_type(argname="argument region", value=region, expected_type=type_hints["region"])
@@ -11799,6 +12639,8 @@ class CnameRecordProps(RecordSetOptions):
             self._values["delete_existing"] = delete_existing
         if geo_location is not None:
             self._values["geo_location"] = geo_location
+        if health_check is not None:
+            self._values["health_check"] = health_check
         if multi_value_answer is not None:
             self._values["multi_value_answer"] = multi_value_answer
         if record_name is not None:
@@ -11853,6 +12695,17 @@ class CnameRecordProps(RecordSetOptions):
         result = self._values.get("geo_location")
         return typing.cast(typing.Optional[GeoLocation], result)
 
+    @builtins.property
+    def health_check(self) -> typing.Optional[IHealthCheck]:
+        '''The health check to associate with the record set.
+
+        Route53 will return this record set in response to DNS queries only if the health check is passing.
+
+        :default: - No health check configured
+        '''
+        result = self._values.get("health_check")
+        return typing.cast(typing.Optional[IHealthCheck], result)
+
     @builtins.property
     def multi_value_answer(self) -> typing.Optional[builtins.bool]:
         '''Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries.
@@ -11986,6 +12839,7 @@ class DsRecord(
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -12001,6 +12855,7 @@ class DsRecord(
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -12018,6 +12873,7 @@ class DsRecord(
             comment=comment,
             delete_existing=delete_existing,
             geo_location=geo_location,
+            health_check=health_check,
             multi_value_answer=multi_value_answer,
             record_name=record_name,
             region=region,
@@ -12037,6 +12893,7 @@ class DsRecord(
         "comment": "comment",
         "delete_existing": "deleteExisting",
         "geo_location": "geoLocation",
+        "health_check": "healthCheck",
         "multi_value_answer": "multiValueAnswer",
         "record_name": "recordName",
         "region": "region",
@@ -12054,6 +12911,7 @@ class DsRecordProps(RecordSetOptions):
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -12068,6 +12926,7 @@ class DsRecordProps(RecordSetOptions):
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -12097,6 +12956,7 @@ class DsRecordProps(RecordSetOptions):
             check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
             check_type(argname="argument delete_existing", value=delete_existing, expected_type=type_hints["delete_existing"])
             check_type(argname="argument geo_location", value=geo_location, expected_type=type_hints["geo_location"])
+            check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
             check_type(argname="argument multi_value_answer", value=multi_value_answer, expected_type=type_hints["multi_value_answer"])
             check_type(argname="argument record_name", value=record_name, expected_type=type_hints["record_name"])
             check_type(argname="argument region", value=region, expected_type=type_hints["region"])
@@ -12114,6 +12974,8 @@ class DsRecordProps(RecordSetOptions):
             self._values["delete_existing"] = delete_existing
         if geo_location is not None:
             self._values["geo_location"] = geo_location
+        if health_check is not None:
+            self._values["health_check"] = health_check
         if multi_value_answer is not None:
             self._values["multi_value_answer"] = multi_value_answer
         if record_name is not None:
@@ -12168,6 +13030,17 @@ class DsRecordProps(RecordSetOptions):
         result = self._values.get("geo_location")
         return typing.cast(typing.Optional[GeoLocation], result)
 
+    @builtins.property
+    def health_check(self) -> typing.Optional[IHealthCheck]:
+        '''The health check to associate with the record set.
+
+        Route53 will return this record set in response to DNS queries only if the health check is passing.
+
+        :default: - No health check configured
+        '''
+        result = self._values.get("health_check")
+        return typing.cast(typing.Optional[IHealthCheck], result)
+
     @builtins.property
     def multi_value_answer(self) -> typing.Optional[builtins.bool]:
         '''Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries.
@@ -12267,6 +13140,153 @@ class DsRecordProps(RecordSetOptions):
         )
 
 
+@jsii.implements(IHealthCheck)
+class HealthCheck(
+    _Resource_45bc6135,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_route53.HealthCheck",
+):
+    '''Amazon Route 53 health checks monitor the health and performance of your web applications, web servers, and other resources.
+
+    Each health check that you create can monitor one of the following:
+
+    - The health of a resource, such as a web server,
+    - The status of other health checks, and
+    - The CloudWatch alarm that you specify,
+    - The status of an Amazon Route 53 routing control.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        # my_zone: route53.HostedZone
+        
+        
+        health_check = route53.HealthCheck(self, "HealthCheck",
+            type=route53.HealthCheckType.HTTP,
+            fqdn="example.com",
+            port=80,
+            resource_path="/health",
+            failure_threshold=3,
+            request_interval=Duration.seconds(30)
+        )
+        
+        route53.ARecord(self, "ARecord",
+            zone=my_zone,
+            target=route53.RecordTarget.from_ip_addresses("1.2.3.4"),
+            health_check=health_check,
+            weight=100
+        )
+        route53.ARecord(self, "ARecord2",
+            zone=my_zone,
+            target=route53.RecordTarget.from_ip_addresses("5.6.7.8"),
+            weight=0
+        )
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        type: HealthCheckType,
+        alarm_identifier: typing.Optional[typing.Union[AlarmIdentifier, typing.Dict[builtins.str, typing.Any]]] = None,
+        child_health_checks: typing.Optional[typing.Sequence[IHealthCheck]] = None,
+        enable_sni: typing.Optional[builtins.bool] = None,
+        failure_threshold: typing.Optional[jsii.Number] = None,
+        fqdn: typing.Optional[builtins.str] = None,
+        health_threshold: typing.Optional[jsii.Number] = None,
+        insufficient_data_health_status: typing.Optional[InsufficientDataHealthStatusEnum] = None,
+        inverted: typing.Optional[builtins.bool] = None,
+        ip_address: typing.Optional[builtins.str] = None,
+        measure_latency: typing.Optional[builtins.bool] = None,
+        port: typing.Optional[jsii.Number] = None,
+        regions: typing.Optional[typing.Sequence[builtins.str]] = None,
+        request_interval: typing.Optional[_Duration_4839e8c3] = None,
+        resource_path: typing.Optional[builtins.str] = None,
+        routing_control: typing.Optional[builtins.str] = None,
+        search_string: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''Creates a new health check.
+
+        :param scope: The parent creating construct (usually ``this``).
+        :param id: The construct's name.
+        :param type: The type of health check to be associated with the record.
+        :param alarm_identifier: CloudWatch alarm that you want Amazon Route 53 health checkers to use to determine whether the specified health check is healthy. Default: - if the type is CLOUDWATCH_METRIC, this property is required. Otherwise, it is not configured.
+        :param child_health_checks: A list of health checks to monitor for this 'CALCULATED' health check. Default: - if the type is CALCULATED, this property is required. Otherwise, it is not configured.
+        :param enable_sni: Specify whether you want Amazon Route 53 to send the value of FullyQualifiedDomainName to the endpoint in the client_hello message during TLS negotiation. This allows the endpoint to respond to HTTPS health check requests with the applicable SSL/TLS certificate. Default: - if the type is HTTPS or HTTPS_STR_MATCH, this property default value is true. Otherwise, it is not configured.
+        :param failure_threshold: The number of consecutive health checks that an endpoint must pass or fail for Amazon Route 53 to change the current status of the endpoint from unhealthy to healthy or vice versa. Default: - if the type is CALCULATED it's not configured - if the type is CLOUDWATCH_METRIC it's not configured - otherwise, the default value is 3.
+        :param fqdn: Fully qualified domain name of the endpoint to be checked. Amazon Route 53 behavior depends on whether you specify a value for IPAddress. If you specify a value for IPAddress: Amazon Route 53 sends health check requests to the specified IPv4 or IPv6 address and passes the value of FullyQualifiedDomainName in the Host header for all health checks except TCP health checks. This is typically the fully qualified DNS name of the endpoint on which you want Route 53 to perform health checks. Note: If you specify a value for Port property other than 80 or 443, Route 53 will constract the value for Host header as FullyQualifiedDomainName:Port. If you don't specify a value for IPAddress: Route 53 sends a DNS request to the domain that you specify for FullyQualifiedDomainName at the interval that you specify for RequestInterval. Using an IPv4 address that DNS returns, Route 53 then checks the health of the endpoint. Additionally, if the type of the health check is HTTP, HTTPS, HTTP_STR_MATCH, or HTTPS_STR_MATCH, Route 53 passes the value of FullyQualifiedDomainName in the Host header, as it does when you specify value for IPAddress. If the type is TCP, Route 53 doesn't pass a Host header. Default: - not configured
+        :param health_threshold: The number of child health checks that are associated with a CALCULATED health that Amazon Route 53 must consider healthy for the CALCULATED health check to be considered healthy. Default: - if the type is CALCULATED, the default value is number of child health checks. Otherwise, it is not configured.
+        :param insufficient_data_health_status: The status of the health check when CloudWatch has insufficient data about the state of associated alarm. Default: - if the type is CLOUDWATCH_METRIC, the default value is InsufficientDataHealthStatus.LAST_KNOWN_STATUS. Otherwise, it is not configured.
+        :param inverted: Specify whether you want Amazon Route 53 to invert the status of a health check, so a health check that would normally be considered unhealthy is considered healthy, and vice versa. Default: false
+        :param ip_address: The IPv4 or IPv6 IP address for the endpoint that you want Amazon Route 53 to perform health checks on. If you don't specify a value for IPAddress, Route 53 sends a DNS request to resolve the domain name that you specify in FullyQualifiedDomainName at the interval that you specify in RequestInterval. Using an IPv4 address that DNS returns, Route 53 then checks the health of the endpoint. Default: - not configured
+        :param measure_latency: Specify whether you want Amazon Route 53 to measure the latency between health checkers in multiple AWS regions and your endpoint, and to display CloudWatch latency graphs on the Health Checks page in the Route 53 console. Default: - if the type is CALCULATED it's not configured - if the type is CLOUDWATCH_METRIC it's not configured - otherwise, the default value is false.
+        :param port: The port on the endpoint that you want Amazon Route 53 to perform health checks on. Default: - if the type is HTTP or HTTP_STR_MATCH, the default value is 80. - if the type is HTTPS or HTTPS_STR_MATCH, the default value is 443. - otherwise, it is not configured.
+        :param regions: An array of region identifiers that you want Amazon Route 53 health checkers to check the health of the endpoint from. Please refer to the CloudFormation documentation for the most up-to-date list of regions. Default: - if the type is CALCULATED, CLOUDWATCH_METRIC, or RECOVERY_CONTROL, this property is not configured. - otherwise, the default value will be set by CloudFormation itself and will include all valid regions. Please refer to the CloudFormation documentation for the most up-to-date list of regions.
+        :param request_interval: The duration between the time that Amazon Route 53 gets a response from your endpoint and the time that it sends the next health check request. Each Route 53 health checker makes requests at this interval. Default: - if the type is CALCULATED it's not configured - if the type is CLOUDWATCH_METRIC it's not configured - otherwise, the default value is 30 seconds.
+        :param resource_path: The path that you want Amazon Route 53 to request when performing health checks. The path can be any value for which your endpoint will return an HTTP status code of 2xx or 3xx when the endpoint is healthy, for example the file /docs/route53-health-check.html. Route 53 automatically adds the DNS name for the service and a leading forward slash (/) character. Default: - if the type is HTTP, HTTPS, HTTP_STR_MATCH, or HTTPS_STR_MATCH, the default value is empty string. - otherwise, it is not configured.
+        :param routing_control: The Amazon Resource Name (ARN) of the Route 53 Application Recovery Controller routing control that you want Amazon Route 53 health checkers to use to determine whether the specified health check is healthy. Default: - if the type is RECOVERY_CONTROL, this property is required. Otherwise, it is not configured.
+        :param search_string: The string that you want Amazon Route 53 to search for in the response body from the specified resource. If the string appears in the response body, Route 53 considers the resource healthy. Route 53 considers case when searching for SearchString in the response body. Default: - if the type is HTTP_STR_MATCH or HTTPS_STR_MATCH, this property is required. Otherwise, it is not configured.
+
+        :return: a reference to the newly created health check.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__8c6121b8faf9b7a92fd3086c1c307dea83166bfd534ca84bbad1637d8c9c1cbd)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        props = HealthCheckProps(
+            type=type,
+            alarm_identifier=alarm_identifier,
+            child_health_checks=child_health_checks,
+            enable_sni=enable_sni,
+            failure_threshold=failure_threshold,
+            fqdn=fqdn,
+            health_threshold=health_threshold,
+            insufficient_data_health_status=insufficient_data_health_status,
+            inverted=inverted,
+            ip_address=ip_address,
+            measure_latency=measure_latency,
+            port=port,
+            regions=regions,
+            request_interval=request_interval,
+            resource_path=resource_path,
+            routing_control=routing_control,
+            search_string=search_string,
+        )
+
+        jsii.create(self.__class__, self, [scope, id, props])
+
+    @jsii.member(jsii_name="fromHealthCheckId")
+    @builtins.classmethod
+    def from_health_check_id(
+        cls,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        health_check_id: builtins.str,
+    ) -> IHealthCheck:
+        '''Import an existing health check into this CDK app.
+
+        :param scope: The parent creating construct (usually ``this``).
+        :param id: The construct's name.
+        :param health_check_id: ID of the health check.
+
+        :return: a reference to the existing health check.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__1574196dfbdf91938d0e48950e72c34106f7e4b227441de8b8df48978fa6c694)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+            check_type(argname="argument health_check_id", value=health_check_id, expected_type=type_hints["health_check_id"])
+        return typing.cast(IHealthCheck, jsii.sinvoke(cls, "fromHealthCheckId", [scope, id, health_check_id]))
+
+    @builtins.property
+    @jsii.member(jsii_name="healthCheckId")
+    def health_check_id(self) -> builtins.str:
+        '''The ID of the health check.'''
+        return typing.cast(builtins.str, jsii.get(self, "healthCheckId"))
+
+
 @jsii.implements(IHostedZone)
 class HostedZone(
     _Resource_45bc6135,
@@ -12507,6 +13527,7 @@ class MxRecord(
         from aws_cdk import aws_route53 as route53
         
         # geo_location: route53.GeoLocation
+        # health_check: route53.HealthCheck
         # hosted_zone: route53.HostedZone
         
         mx_record = route53.MxRecord(self, "MyMxRecord",
@@ -12520,6 +13541,7 @@ class MxRecord(
             comment="comment",
             delete_existing=False,
             geo_location=geo_location,
+            health_check=health_check,
             multi_value_answer=False,
             record_name="recordName",
             region="region",
@@ -12539,6 +13561,7 @@ class MxRecord(
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -12554,6 +13577,7 @@ class MxRecord(
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -12571,6 +13595,7 @@ class MxRecord(
             comment=comment,
             delete_existing=delete_existing,
             geo_location=geo_location,
+            health_check=health_check,
             multi_value_answer=multi_value_answer,
             record_name=record_name,
             region=region,
@@ -12590,6 +13615,7 @@ class MxRecord(
         "comment": "comment",
         "delete_existing": "deleteExisting",
         "geo_location": "geoLocation",
+        "health_check": "healthCheck",
         "multi_value_answer": "multiValueAnswer",
         "record_name": "recordName",
         "region": "region",
@@ -12607,6 +13633,7 @@ class MxRecordProps(RecordSetOptions):
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -12621,6 +13648,7 @@ class MxRecordProps(RecordSetOptions):
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -12639,6 +13667,7 @@ class MxRecordProps(RecordSetOptions):
             from aws_cdk import aws_route53 as route53
             
             # geo_location: route53.GeoLocation
+            # health_check: route53.HealthCheck
             # hosted_zone: route53.HostedZone
             
             mx_record_props = route53.MxRecordProps(
@@ -12652,6 +13681,7 @@ class MxRecordProps(RecordSetOptions):
                 comment="comment",
                 delete_existing=False,
                 geo_location=geo_location,
+                health_check=health_check,
                 multi_value_answer=False,
                 record_name="recordName",
                 region="region",
@@ -12666,6 +13696,7 @@ class MxRecordProps(RecordSetOptions):
             check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
             check_type(argname="argument delete_existing", value=delete_existing, expected_type=type_hints["delete_existing"])
             check_type(argname="argument geo_location", value=geo_location, expected_type=type_hints["geo_location"])
+            check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
             check_type(argname="argument multi_value_answer", value=multi_value_answer, expected_type=type_hints["multi_value_answer"])
             check_type(argname="argument record_name", value=record_name, expected_type=type_hints["record_name"])
             check_type(argname="argument region", value=region, expected_type=type_hints["region"])
@@ -12683,6 +13714,8 @@ class MxRecordProps(RecordSetOptions):
             self._values["delete_existing"] = delete_existing
         if geo_location is not None:
             self._values["geo_location"] = geo_location
+        if health_check is not None:
+            self._values["health_check"] = health_check
         if multi_value_answer is not None:
             self._values["multi_value_answer"] = multi_value_answer
         if record_name is not None:
@@ -12737,6 +13770,17 @@ class MxRecordProps(RecordSetOptions):
         result = self._values.get("geo_location")
         return typing.cast(typing.Optional[GeoLocation], result)
 
+    @builtins.property
+    def health_check(self) -> typing.Optional[IHealthCheck]:
+        '''The health check to associate with the record set.
+
+        Route53 will return this record set in response to DNS queries only if the health check is passing.
+
+        :default: - No health check configured
+        '''
+        result = self._values.get("health_check")
+        return typing.cast(typing.Optional[IHealthCheck], result)
+
     @builtins.property
     def multi_value_answer(self) -> typing.Optional[builtins.bool]:
         '''Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries.
@@ -12870,6 +13914,7 @@ class NsRecord(
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -12885,6 +13930,7 @@ class NsRecord(
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -12902,6 +13948,7 @@ class NsRecord(
             comment=comment,
             delete_existing=delete_existing,
             geo_location=geo_location,
+            health_check=health_check,
             multi_value_answer=multi_value_answer,
             record_name=record_name,
             region=region,
@@ -12921,6 +13968,7 @@ class NsRecord(
         "comment": "comment",
         "delete_existing": "deleteExisting",
         "geo_location": "geoLocation",
+        "health_check": "healthCheck",
         "multi_value_answer": "multiValueAnswer",
         "record_name": "recordName",
         "region": "region",
@@ -12938,6 +13986,7 @@ class NsRecordProps(RecordSetOptions):
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -12952,6 +14001,7 @@ class NsRecordProps(RecordSetOptions):
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -12981,6 +14031,7 @@ class NsRecordProps(RecordSetOptions):
             check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
             check_type(argname="argument delete_existing", value=delete_existing, expected_type=type_hints["delete_existing"])
             check_type(argname="argument geo_location", value=geo_location, expected_type=type_hints["geo_location"])
+            check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
             check_type(argname="argument multi_value_answer", value=multi_value_answer, expected_type=type_hints["multi_value_answer"])
             check_type(argname="argument record_name", value=record_name, expected_type=type_hints["record_name"])
             check_type(argname="argument region", value=region, expected_type=type_hints["region"])
@@ -12998,6 +14049,8 @@ class NsRecordProps(RecordSetOptions):
             self._values["delete_existing"] = delete_existing
         if geo_location is not None:
             self._values["geo_location"] = geo_location
+        if health_check is not None:
+            self._values["health_check"] = health_check
         if multi_value_answer is not None:
             self._values["multi_value_answer"] = multi_value_answer
         if record_name is not None:
@@ -13052,6 +14105,17 @@ class NsRecordProps(RecordSetOptions):
         result = self._values.get("geo_location")
         return typing.cast(typing.Optional[GeoLocation], result)
 
+    @builtins.property
+    def health_check(self) -> typing.Optional[IHealthCheck]:
+        '''The health check to associate with the record set.
+
+        Route53 will return this record set in response to DNS queries only if the health check is passing.
+
+        :default: - No health check configured
+        '''
+        result = self._values.get("health_check")
+        return typing.cast(typing.Optional[IHealthCheck], result)
+
     @builtins.property
     def multi_value_answer(self) -> typing.Optional[builtins.bool]:
         '''Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries.
@@ -13427,6 +14491,7 @@ class CaaAmazonRecord(
         from aws_cdk import aws_route53 as route53
         
         # geo_location: route53.GeoLocation
+        # health_check: route53.HealthCheck
         # hosted_zone: route53.HostedZone
         
         caa_amazon_record = route53.CaaAmazonRecord(self, "MyCaaAmazonRecord",
@@ -13436,6 +14501,7 @@ class CaaAmazonRecord(
             comment="comment",
             delete_existing=False,
             geo_location=geo_location,
+            health_check=health_check,
             multi_value_answer=False,
             record_name="recordName",
             region="region",
@@ -13454,6 +14520,7 @@ class CaaAmazonRecord(
         comment: typing.Optional[builtins.str] = None,
         delete_existing: typing.Optional[builtins.bool] = None,
         geo_location: typing.Optional[GeoLocation] = None,
+        health_check: typing.Optional[IHealthCheck] = None,
         multi_value_answer: typing.Optional[builtins.bool] = None,
         record_name: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
@@ -13468,6 +14535,7 @@ class CaaAmazonRecord(
         :param comment: A comment to add on the record. Default: no comment
         :param delete_existing: Whether to delete the same record set in the hosted zone if it already exists (dangerous!). This allows to deploy a new record set while minimizing the downtime because the new record set will be created immediately after the existing one is deleted. It also avoids "manual" actions to delete existing record sets. .. epigraph:: **N.B.:** this feature is dangerous, use with caution! It can only be used safely when ``deleteExisting`` is set to ``true`` as soon as the resource is added to the stack. Changing an existing Record Set's ``deleteExisting`` property from ``false -> true`` after deployment will delete the record! Default: false
         :param geo_location: The geographical origin for this record to return DNS records based on the user's location.
+        :param health_check: The health check to associate with the record set. Route53 will return this record set in response to DNS queries only if the health check is passing. Default: - No health check configured
         :param multi_value_answer: Whether to return multiple values, such as IP addresses for your web servers, in response to DNS queries. Default: false
         :param record_name: The subdomain name for this record. This should be relative to the zone root name. For example, if you want to create a record for acme.example.com, specify "acme". You can also specify the fully qualified domain name which terminates with a ".". For example, "acme.example.com.". Default: zone root
         :param region: The Amazon EC2 Region where you created the resource that this resource record set refers to. The resource typically is an AWS resource, such as an EC2 instance or an ELB load balancer, and is referred to by an IP address or a DNS domain name, depending on the record type. When Amazon Route 53 receives a DNS query for a domain name and type for which you have created latency resource record sets, Route 53 selects the latency resource record set that has the lowest latency between the end user and the associated Amazon EC2 Region. Route 53 then returns the value that is associated with the selected resource record set. Default: - Do not set latency based routing
@@ -13484,6 +14552,7 @@ class CaaAmazonRecord(
             comment=comment,
             delete_existing=delete_existing,
             geo_location=geo_location,
+            health_check=health_check,
             multi_value_answer=multi_value_answer,
             record_name=record_name,
             region=region,
@@ -13501,6 +14570,7 @@ __all__ = [
     "ARecordProps",
     "AaaaRecord",
     "AaaaRecordProps",
+    "AlarmIdentifier",
     "AliasRecordTargetConfig",
     "CaaAmazonRecord",
     "CaaAmazonRecordProps",
@@ -13531,16 +14601,21 @@ __all__ = [
     "DsRecord",
     "DsRecordProps",
     "GeoLocation",
+    "HealthCheck",
+    "HealthCheckProps",
+    "HealthCheckType",
     "HostedZone",
     "HostedZoneAttributes",
     "HostedZoneProps",
     "HostedZoneProviderProps",
     "IAliasRecordTarget",
+    "IHealthCheck",
     "IHostedZone",
     "IKeySigningKey",
     "IPrivateHostedZone",
     "IPublicHostedZone",
     "IRecordSet",
+    "InsufficientDataHealthStatusEnum",
     "KeySigningKey",
     "KeySigningKeyAttributes",
     "KeySigningKeyProps",
@@ -13575,10 +14650,19 @@ __all__ = [
 
 publication.publish()
 
+def _typecheckingstub__fcd95e6a7e14c758d746168914f9e2a2b5cd382fbfbc8277ef45a5aee3a652fa(
+    *,
+    name: builtins.str,
+    region: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__387b486cd004971b31128e4032ad0c37e74eea08888305d1660803aa68158e99(
     *,
     dns_name: builtins.str,
     hosted_zone_id: builtins.str,
+    evaluate_target_health: typing.Optional[builtins.bool] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -14298,6 +15382,29 @@ def _typecheckingstub__13d57b34e60c4361c1d97c820e69f3a9c16ba208b123a261ee081931b
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__aa97034136188f7866c26cd6fb12cf33983958b5147a7092dea7494be1142b56(
+    *,
+    type: HealthCheckType,
+    alarm_identifier: typing.Optional[typing.Union[AlarmIdentifier, typing.Dict[builtins.str, typing.Any]]] = None,
+    child_health_checks: typing.Optional[typing.Sequence[IHealthCheck]] = None,
+    enable_sni: typing.Optional[builtins.bool] = None,
+    failure_threshold: typing.Optional[jsii.Number] = None,
+    fqdn: typing.Optional[builtins.str] = None,
+    health_threshold: typing.Optional[jsii.Number] = None,
+    insufficient_data_health_status: typing.Optional[InsufficientDataHealthStatusEnum] = None,
+    inverted: typing.Optional[builtins.bool] = None,
+    ip_address: typing.Optional[builtins.str] = None,
+    measure_latency: typing.Optional[builtins.bool] = None,
+    port: typing.Optional[jsii.Number] = None,
+    regions: typing.Optional[typing.Sequence[builtins.str]] = None,
+    request_interval: typing.Optional[_Duration_4839e8c3] = None,
+    resource_path: typing.Optional[builtins.str] = None,
+    routing_control: typing.Optional[builtins.str] = None,
+    search_string: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__e5fad1cc6999b94bd845480426db92d5bb3ac0208bca78f9cf984e5ce4ccd701(
     *,
     hosted_zone_id: builtins.str,
@@ -14429,6 +15536,7 @@ def _typecheckingstub__b92f4bc0484ad6fe8cce3c7e37b4ee3cd051b8f325d16efd23f924767
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14445,6 +15553,7 @@ def _typecheckingstub__c44f39638a001e90bc1175667e4764c4cbde27cade202d52a4f4d8724
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14461,6 +15570,7 @@ def _typecheckingstub__038200686c47ef30f81bc5289a6235e766372281295129670053b793d
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14507,6 +15617,7 @@ def _typecheckingstub__d52a70fbe22ca5e13acce72254719ea0dd37b436de0640b65774aadd9
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14523,6 +15634,7 @@ def _typecheckingstub__803828161f541995c058596dab53102f2eccd14ba565bbe715a5ac293
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14553,6 +15665,7 @@ def _typecheckingstub__df1e0c1447d860a09246a7ec54507ca123346e57365df024460258839
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14569,6 +15682,7 @@ def _typecheckingstub__1925dd23d881cbbf99625b9a5fe0ef65b92a92359376c46e49b6690f1
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14623,6 +15737,7 @@ def _typecheckingstub__1f8360676c13e2167bb58d36e1b6384ba70f036979aa9c80cac046e12
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14639,6 +15754,7 @@ def _typecheckingstub__240a965753acb9488d02c120074027364f5e85a8ec585205a863174fe
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14667,6 +15783,7 @@ def _typecheckingstub__ca2e60ba6b2baeeff2cc875c86af94b4b26d6f11c1cfcca09280ac533
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14686,6 +15803,7 @@ def _typecheckingstub__c76ad72e64542d58d5e33c28ccaca560dac09b21c920d094b7a0c2386
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14702,6 +15820,7 @@ def _typecheckingstub__514d7eccc21be019febe80e121fd7d979162668b63cb99051c629ef08
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14719,6 +15838,7 @@ def _typecheckingstub__a73a5c86411a0d853fcfad820ed58f5a5c19df65a7b2756560958db5c
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14739,6 +15859,7 @@ def _typecheckingstub__4d5345c027ebd51f32f58fdeb055904a5c4dd3f5523f55954f8a191ae
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14755,6 +15876,7 @@ def _typecheckingstub__c051ff70083b2ae68889d3f02be8344125acf64b4768d5f5df3298ba8
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14772,6 +15894,7 @@ def _typecheckingstub__14055fdb7d9f4b55091295996ec92db8d73fa789a21fca2664da1242a
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14791,6 +15914,7 @@ def _typecheckingstub__3a2502cdc1fe021e837217ab0d96b9fa6ea450a68c089482935b695f7
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14807,6 +15931,7 @@ def _typecheckingstub__349a94b990ddb833b270dc692692a8b37187c6f17114e02514f44accf
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14827,6 +15952,7 @@ def _typecheckingstub__e8dfccd8504bb3c0a779b42a665f362282b1083fe52a95b450d1ac1eb
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14843,6 +15969,7 @@ def _typecheckingstub__43b5fc8ccb719e2580c804225e8258b57b1700a701203416558eb2d76
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14863,6 +15990,7 @@ def _typecheckingstub__24205d1a44dcefb992b7bd9b6d91d8b6396f8498224c30876fe8a0673
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14879,6 +16007,7 @@ def _typecheckingstub__f86f16d9f2de8fe03cc1189a56a86c4888d20f69dc0f241aa21b50fdf
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14890,6 +16019,39 @@ def _typecheckingstub__f86f16d9f2de8fe03cc1189a56a86c4888d20f69dc0f241aa21b50fdf
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__8c6121b8faf9b7a92fd3086c1c307dea83166bfd534ca84bbad1637d8c9c1cbd(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    type: HealthCheckType,
+    alarm_identifier: typing.Optional[typing.Union[AlarmIdentifier, typing.Dict[builtins.str, typing.Any]]] = None,
+    child_health_checks: typing.Optional[typing.Sequence[IHealthCheck]] = None,
+    enable_sni: typing.Optional[builtins.bool] = None,
+    failure_threshold: typing.Optional[jsii.Number] = None,
+    fqdn: typing.Optional[builtins.str] = None,
+    health_threshold: typing.Optional[jsii.Number] = None,
+    insufficient_data_health_status: typing.Optional[InsufficientDataHealthStatusEnum] = None,
+    inverted: typing.Optional[builtins.bool] = None,
+    ip_address: typing.Optional[builtins.str] = None,
+    measure_latency: typing.Optional[builtins.bool] = None,
+    port: typing.Optional[jsii.Number] = None,
+    regions: typing.Optional[typing.Sequence[builtins.str]] = None,
+    request_interval: typing.Optional[_Duration_4839e8c3] = None,
+    resource_path: typing.Optional[builtins.str] = None,
+    routing_control: typing.Optional[builtins.str] = None,
+    search_string: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__1574196dfbdf91938d0e48950e72c34106f7e4b227441de8b8df48978fa6c694(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    health_check_id: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__1e5b9f9d7aa4bc16fced3cc22e63b14cbf590c498be223e588483a72fb0b4233(
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
@@ -14953,6 +16115,7 @@ def _typecheckingstub__615153e942ef5cdcb0022d4565e0ec8b8c5554594bfe7221366ad5c83
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14969,6 +16132,7 @@ def _typecheckingstub__b259122626a3ba94eebff0b5f692944df4aa55dc550b7d113eec491e1
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -14989,6 +16153,7 @@ def _typecheckingstub__7f3bbcb4bd5bcd8978ae60eaac5ea2c6ab0bb8357a389e9b981e63291
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -15005,6 +16170,7 @@ def _typecheckingstub__33cda5fac8572316158161da713e2ceea9d3f7f56b5ee9a2a25acf331
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
@@ -15093,6 +16259,7 @@ def _typecheckingstub__f189380057459afbeff6d38749625e3756c4572dec90f74ca7a400dcb
     comment: typing.Optional[builtins.str] = None,
     delete_existing: typing.Optional[builtins.bool] = None,
     geo_location: typing.Optional[GeoLocation] = None,
+    health_check: typing.Optional[IHealthCheck] = None,
     multi_value_answer: typing.Optional[builtins.bool] = None,
     record_name: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,