aws-cdk-lib 2.128.0__py3-none-any.whl → 2.130.0__py3-none-any.whl

aws_cdk/aws_route53/__init__.py

@@ -2086,10 +2086,7 @@ class CfnHostedZone(
     @builtins.property
     @jsii.member(jsii_name="attrNameServers")
     def attr_name_servers(self) -> typing.List[builtins.str]:
-        '''Returns the set of name servers for the specific hosted zone. For example: ``ns1.example.com`` .
-
-        This attribute is not supported for private hosted zones.
-
+        '''
         :cloudformationAttribute: NameServers
         '''
         return typing.cast(typing.List[builtins.str], jsii.get(self, "attrNameServers"))
@@ -2966,6 +2963,15 @@ class CfnRecordSet(
                 country_code="countryCode",
                 subdivision_code="subdivisionCode"
             ),
+            geo_proximity_location=route53.CfnRecordSet.GeoProximityLocationProperty(
+                aws_region="awsRegion",
+                bias=123,
+                coordinates=route53.CfnRecordSet.CoordinatesProperty(
+                    latitude="latitude",
+                    longitude="longitude"
+                ),
+                local_zone_group="localZoneGroup"
+            ),
             health_check_id="healthCheckId",
             hosted_zone_id="hostedZoneId",
             hosted_zone_name="hostedZoneName",
@@ -2990,6 +2996,7 @@ class CfnRecordSet(
         comment: typing.Optional[builtins.str] = None,
         failover: typing.Optional[builtins.str] = None,
         geo_location: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnRecordSet.GeoLocationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+        geo_proximity_location: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnRecordSet.GeoProximityLocationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         health_check_id: typing.Optional[builtins.str] = None,
         hosted_zone_id: typing.Optional[builtins.str] = None,
         hosted_zone_name: typing.Optional[builtins.str] = None,
@@ -3010,6 +3017,7 @@ class CfnRecordSet(
         :param comment: *Optional:* Any comments you want to include about a change batch request.
         :param failover: *Failover resource record sets only:* To configure failover, you add the ``Failover`` element to two resource record sets. For one resource record set, you specify ``PRIMARY`` as the value for ``Failover`` ; for the other resource record set, you specify ``SECONDARY`` . In addition, you include the ``HealthCheckId`` element and specify the health check that you want Amazon Route 53 to perform for each resource record set. Except where noted, the following failover behaviors assume that you have included the ``HealthCheckId`` element in both resource record sets: - When the primary resource record set is healthy, Route 53 responds to DNS queries with the applicable value from the primary resource record set regardless of the health of the secondary resource record set. - When the primary resource record set is unhealthy and the secondary resource record set is healthy, Route 53 responds to DNS queries with the applicable value from the secondary resource record set. - When the secondary resource record set is unhealthy, Route 53 responds to DNS queries with the applicable value from the primary resource record set regardless of the health of the primary resource record set. - If you omit the ``HealthCheckId`` element for the secondary resource record set, and if the primary resource record set is unhealthy, Route 53 always responds to DNS queries with the applicable value from the secondary resource record set. This is true regardless of the health of the associated endpoint. You can't create non-failover resource record sets that have the same values for the ``Name`` and ``Type`` elements as failover resource record sets. For failover alias resource record sets, you must also include the ``EvaluateTargetHealth`` element and set the value to true. For more information about configuring failover for Route 53, see the following topics in the *Amazon Route 53 Developer Guide* : - `Route 53 Health Checks and DNS Failover <https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover.html>`_ - `Configuring Failover in a Private Hosted Zone <https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-private-hosted-zones.html>`_
         :param geo_location: *Geolocation resource record sets only:* A complex type that lets you control how Amazon Route 53 responds to DNS queries based on the geographic origin of the query. For example, if you want all queries from Africa to be routed to a web server with an IP address of ``192.0.2.111`` , create a resource record set with a ``Type`` of ``A`` and a ``ContinentCode`` of ``AF`` . If you create separate resource record sets for overlapping geographic regions (for example, one resource record set for a continent and one for a country on the same continent), priority goes to the smallest geographic region. This allows you to route most queries for a continent to one resource and to route queries for a country on that continent to a different resource. You can't create two geolocation resource record sets that specify the same geographic location. The value ``*`` in the ``CountryCode`` element matches all geographic locations that aren't specified in other geolocation resource record sets that have the same values for the ``Name`` and ``Type`` elements. .. epigraph:: Geolocation works by mapping IP addresses to locations. However, some IP addresses aren't mapped to geographic locations, so even if you create geolocation resource record sets that cover all seven continents, Route 53 will receive some DNS queries from locations that it can't identify. We recommend that you create a resource record set for which the value of ``CountryCode`` is ``*`` . Two groups of queries are routed to the resource that you specify in this record: queries that come from locations for which you haven't created geolocation resource record sets and queries from IP addresses that aren't mapped to a location. If you don't create a ``*`` resource record set, Route 53 returns a "no answer" response for queries from those locations. You can't create non-geolocation resource record sets that have the same values for the ``Name`` and ``Type`` elements as geolocation resource record sets.
+        :param geo_proximity_location: *GeoproximityLocation resource record sets only:* A complex type that lets you control how Route 53 responds to DNS queries based on the geographic origin of the query and your resources.
         :param health_check_id: If you want Amazon Route 53 to return this resource record set in response to a DNS query only when the status of a health check is healthy, include the ``HealthCheckId`` element and specify the ID of the applicable health check. Route 53 determines whether a resource record set is healthy based on one of the following: - By periodically sending a request to the endpoint that is specified in the health check - By aggregating the status of a specified group of health checks (calculated health checks) - By determining the current state of a CloudWatch alarm (CloudWatch metric health checks) .. epigraph:: Route 53 doesn't check the health of the endpoint that is specified in the resource record set, for example, the endpoint specified by the IP address in the ``Value`` element. When you add a ``HealthCheckId`` element to a resource record set, Route 53 checks the health of the endpoint that you specified in the health check. For more information, see the following topics in the *Amazon Route 53 Developer Guide* : - `How Amazon Route 53 Determines Whether an Endpoint Is Healthy <https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-determining-health-of-endpoints.html>`_ - `Route 53 Health Checks and DNS Failover <https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover.html>`_ - `Configuring Failover in a Private Hosted Zone <https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-private-hosted-zones.html>`_ *When to Specify HealthCheckId* Specifying a value for ``HealthCheckId`` is useful only when Route 53 is choosing between two or more resource record sets to respond to a DNS query, and you want Route 53 to base the choice in part on the status of a health check. Configuring health checks makes sense only in the following configurations: - *Non-alias resource record sets* : You're checking the health of a group of non-alias resource record sets that have the same routing policy, name, and type (such as multiple weighted records named www.example.com with a type of A) and you specify health check IDs for all the resource record sets. If the health check status for a resource record set is healthy, Route 53 includes the record among the records that it responds to DNS queries with. If the health check status for a resource record set is unhealthy, Route 53 stops responding to DNS queries using the value for that resource record set. If the health check status for all resource record sets in the group is unhealthy, Route 53 considers all resource record sets in the group healthy and responds to DNS queries accordingly. - *Alias resource record sets* : You specify the following settings: - You set ``EvaluateTargetHealth`` to true for an alias resource record set in a group of resource record sets that have the same routing policy, name, and type (such as multiple weighted records named www.example.com with a type of A). - You configure the alias resource record set to route traffic to a non-alias resource record set in the same hosted zone. - You specify a health check ID for the non-alias resource record set. If the health check status is healthy, Route 53 considers the alias resource record set to be healthy and includes the alias record among the records that it responds to DNS queries with. If the health check status is unhealthy, Route 53 stops responding to DNS queries using the alias resource record set. .. epigraph:: The alias resource record set can also route traffic to a *group* of non-alias resource record sets that have the same routing policy, name, and type. In that configuration, associate health checks with all of the resource record sets in the group of non-alias resource record sets. *Geolocation Routing* For geolocation resource record sets, if an endpoint is unhealthy, Route 53 looks for a resource record set for the larger, associated geographic region. For example, suppose you have resource record sets for a state in the United States, for the entire United States, for North America, and a resource record set that has ``*`` for ``CountryCode`` is ``*`` , which applies to all locations. If the endpoint for the state resource record set is unhealthy, Route 53 checks for healthy resource record sets in the following order until it finds a resource record set for which the endpoint is healthy: - The United States - North America - The default resource record set *Specifying the Health Check Endpoint by Domain Name* If your health checks specify the endpoint only by domain name, we recommend that you create a separate health check for each endpoint. For example, create a health check for each ``HTTP`` server that is serving content for ``www.example.com`` . For the value of ``FullyQualifiedDomainName`` , specify the domain name of the server (such as ``us-east-2-www.example.com`` ), not the name of the resource record sets ( ``www.example.com`` ). .. epigraph:: Health check results will be unpredictable if you do the following: - Create a health check that has the same value for ``FullyQualifiedDomainName`` as the name of a resource record set. - Associate that health check with the resource record set.
         :param hosted_zone_id: The ID of the hosted zone that you want to create records in. Specify either ``HostedZoneName`` or ``HostedZoneId`` , but not both. If you have multiple hosted zones with the same domain name, you must specify the hosted zone using ``HostedZoneId`` .
         :param hosted_zone_name: The name of the hosted zone that you want to create records in. You must include a trailing dot (for example, ``www.example.com.`` ) as part of the ``HostedZoneName`` . When you create a stack using an AWS::Route53::RecordSet that specifies ``HostedZoneName`` , AWS CloudFormation attempts to find a hosted zone whose name matches the HostedZoneName. If AWS CloudFormation cannot find a hosted zone with a matching domain name, or if there is more than one hosted zone with the specified domain name, AWS CloudFormation will not create the stack. Specify either ``HostedZoneName`` or ``HostedZoneId`` , but not both. If you have multiple hosted zones with the same domain name, you must specify the hosted zone using ``HostedZoneId`` .
@@ -3032,6 +3040,7 @@ class CfnRecordSet(
             comment=comment,
             failover=failover,
             geo_location=geo_location,
+            geo_proximity_location=geo_proximity_location,
             health_check_id=health_check_id,
             hosted_zone_id=hosted_zone_id,
             hosted_zone_name=hosted_zone_name,
@@ -3078,7 +3087,8 @@ class CfnRecordSet(
     @builtins.property
     @jsii.member(jsii_name="attrId")
     def attr_id(self) -> builtins.str:
-        '''
+        '''Specifies a coordinate of the east–west position of a geographic point on the surface of the Earth.
+
         :cloudformationAttribute: Id
         '''
         return typing.cast(builtins.str, jsii.get(self, "attrId"))
@@ -3194,6 +3204,24 @@ class CfnRecordSet(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "geoLocation", value)
 
+    @builtins.property
+    @jsii.member(jsii_name="geoProximityLocation")
+    def geo_proximity_location(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnRecordSet.GeoProximityLocationProperty"]]:
+        '''*GeoproximityLocation resource record sets only:* A complex type that lets you control how Route 53 responds to DNS queries based on the geographic origin of the query and your resources.'''
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnRecordSet.GeoProximityLocationProperty"]], jsii.get(self, "geoProximityLocation"))
+
+    @geo_proximity_location.setter
+    def geo_proximity_location(
+        self,
+        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnRecordSet.GeoProximityLocationProperty"]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__ac8d1aee0fc5c4e2eba653391bb8b61826a08b6708db398bae5b22b4e13fcf05)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "geoProximityLocation", value)
+
     @builtins.property
     @jsii.member(jsii_name="healthCheckId")
     def health_check_id(self) -> typing.Optional[builtins.str]:
@@ -3599,6 +3627,72 @@ class CfnRecordSet(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_route53.CfnRecordSet.CoordinatesProperty",
+        jsii_struct_bases=[],
+        name_mapping={"latitude": "latitude", "longitude": "longitude"},
+    )
+    class CoordinatesProperty:
+        def __init__(self, *, latitude: builtins.str, longitude: builtins.str) -> None:
+            '''A complex type that lists the coordinates for a geoproximity resource record.
+
+            :param latitude: Specifies a coordinate of the north–south position of a geographic point on the surface of the Earth (-90 - 90).
+            :param longitude: Specifies a coordinate of the east–west position of a geographic point on the surface of the Earth (-180 - 180).
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53-recordset-coordinates.html
+            :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
+                
+                coordinates_property = route53.CfnRecordSet.CoordinatesProperty(
+                    latitude="latitude",
+                    longitude="longitude"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__29683fc8d824969c71955a00cda4d10dde445180eb16e6a17c990ec1252a893a)
+                check_type(argname="argument latitude", value=latitude, expected_type=type_hints["latitude"])
+                check_type(argname="argument longitude", value=longitude, expected_type=type_hints["longitude"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "latitude": latitude,
+                "longitude": longitude,
+            }
+
+        @builtins.property
+        def latitude(self) -> builtins.str:
+            '''Specifies a coordinate of the north–south position of a geographic point on the surface of the Earth (-90 - 90).
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53-recordset-coordinates.html#cfn-route53-recordset-coordinates-latitude
+            '''
+            result = self._values.get("latitude")
+            assert result is not None, "Required property 'latitude' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def longitude(self) -> builtins.str:
+            '''Specifies a coordinate of the east–west position of a geographic point on the surface of the Earth (-180 - 180).
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53-recordset-coordinates.html#cfn-route53-recordset-coordinates-longitude
+            '''
+            result = self._values.get("longitude")
+            assert result is not None, "Required property 'longitude' 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 "CoordinatesProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_route53.CfnRecordSet.GeoLocationProperty",
         jsii_struct_bases=[],
@@ -3704,6 +3798,131 @@ class CfnRecordSet(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_route53.CfnRecordSet.GeoProximityLocationProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "aws_region": "awsRegion",
+            "bias": "bias",
+            "coordinates": "coordinates",
+            "local_zone_group": "localZoneGroup",
+        },
+    )
+    class GeoProximityLocationProperty:
+        def __init__(
+            self,
+            *,
+            aws_region: typing.Optional[builtins.str] = None,
+            bias: typing.Optional[jsii.Number] = None,
+            coordinates: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnRecordSet.CoordinatesProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            local_zone_group: typing.Optional[builtins.str] = None,
+        ) -> None:
+            '''(Resource record sets only): A complex type that lets you specify where your resources are located.
+
+            Only one of ``LocalZoneGroup`` , ``Coordinates`` , or ``AWS Region`` is allowed per request at a time.
+
+            For more information about geoproximity routing, see `Geoproximity routing <https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-geoproximity.html>`_ in the *Amazon Route 53 Developer Guide* .
+
+            :param aws_region: The AWS Region the resource you are directing DNS traffic to, is in.
+            :param bias: The bias increases or decreases the size of the geographic region from which Route 53 routes traffic to a resource. To use ``Bias`` to change the size of the geographic region, specify the applicable value for the bias: - To expand the size of the geographic region from which Route 53 routes traffic to a resource, specify a positive integer from 1 to 99 for the bias. Route 53 shrinks the size of adjacent regions. - To shrink the size of the geographic region from which Route 53 routes traffic to a resource, specify a negative bias of -1 to -99. Route 53 expands the size of adjacent regions.
+            :param coordinates: Contains the longitude and latitude for a geographic region.
+            :param local_zone_group: Specifies an AWS Local Zone Group. A local Zone Group is usually the Local Zone code without the ending character. For example, if the Local Zone is ``us-east-1-bue-1a`` the Local Zone Group is ``us-east-1-bue-1`` . You can identify the Local Zones Group for a specific Local Zone by using the `describe-availability-zones <https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-availability-zones.html>`_ CLI command: This command returns: ``"GroupName": "us-west-2-den-1"`` , specifying that the Local Zone ``us-west-2-den-1a`` belongs to the Local Zone Group ``us-west-2-den-1`` .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53-recordset-geoproximitylocation.html
+            :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
+                
+                geo_proximity_location_property = route53.CfnRecordSet.GeoProximityLocationProperty(
+                    aws_region="awsRegion",
+                    bias=123,
+                    coordinates=route53.CfnRecordSet.CoordinatesProperty(
+                        latitude="latitude",
+                        longitude="longitude"
+                    ),
+                    local_zone_group="localZoneGroup"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__9bbef31bd9d19fea78e067206e8cea17ada33bda9853588d7a99d66d91f15555)
+                check_type(argname="argument aws_region", value=aws_region, expected_type=type_hints["aws_region"])
+                check_type(argname="argument bias", value=bias, expected_type=type_hints["bias"])
+                check_type(argname="argument coordinates", value=coordinates, expected_type=type_hints["coordinates"])
+                check_type(argname="argument local_zone_group", value=local_zone_group, expected_type=type_hints["local_zone_group"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if aws_region is not None:
+                self._values["aws_region"] = aws_region
+            if bias is not None:
+                self._values["bias"] = bias
+            if coordinates is not None:
+                self._values["coordinates"] = coordinates
+            if local_zone_group is not None:
+                self._values["local_zone_group"] = local_zone_group
+
+        @builtins.property
+        def aws_region(self) -> typing.Optional[builtins.str]:
+            '''The AWS Region the resource you are directing DNS traffic to, is in.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53-recordset-geoproximitylocation.html#cfn-route53-recordset-geoproximitylocation-awsregion
+            '''
+            result = self._values.get("aws_region")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def bias(self) -> typing.Optional[jsii.Number]:
+            '''The bias increases or decreases the size of the geographic region from which Route 53 routes traffic to a resource.
+
+            To use ``Bias`` to change the size of the geographic region, specify the applicable value for the bias:
+
+            - To expand the size of the geographic region from which Route 53 routes traffic to a resource, specify a positive integer from 1 to 99 for the bias. Route 53 shrinks the size of adjacent regions.
+            - To shrink the size of the geographic region from which Route 53 routes traffic to a resource, specify a negative bias of -1 to -99. Route 53 expands the size of adjacent regions.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53-recordset-geoproximitylocation.html#cfn-route53-recordset-geoproximitylocation-bias
+            '''
+            result = self._values.get("bias")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def coordinates(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnRecordSet.CoordinatesProperty"]]:
+            '''Contains the longitude and latitude for a geographic region.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53-recordset-geoproximitylocation.html#cfn-route53-recordset-geoproximitylocation-coordinates
+            '''
+            result = self._values.get("coordinates")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnRecordSet.CoordinatesProperty"]], result)
+
+        @builtins.property
+        def local_zone_group(self) -> typing.Optional[builtins.str]:
+            '''Specifies an AWS Local Zone Group.
+
+            A local Zone Group is usually the Local Zone code without the ending character. For example, if the Local Zone is ``us-east-1-bue-1a`` the Local Zone Group is ``us-east-1-bue-1`` .
+
+            You can identify the Local Zones Group for a specific Local Zone by using the `describe-availability-zones <https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-availability-zones.html>`_ CLI command:
+
+            This command returns: ``"GroupName": "us-west-2-den-1"`` , specifying that the Local Zone ``us-west-2-den-1a`` belongs to the Local Zone Group ``us-west-2-den-1`` .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53-recordset-geoproximitylocation.html#cfn-route53-recordset-geoproximitylocation-localzonegroup
+            '''
+            result = self._values.get("local_zone_group")
+            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 "GeoProximityLocationProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
 
 @jsii.implements(_IInspectable_c2943556)
 class CfnRecordSetGroup(
@@ -3749,6 +3968,15 @@ class CfnRecordSetGroup(
                     country_code="countryCode",
                     subdivision_code="subdivisionCode"
                 ),
+                geo_proximity_location=route53.CfnRecordSetGroup.GeoProximityLocationProperty(
+                    aws_region="awsRegion",
+                    bias=123,
+                    coordinates=route53.CfnRecordSetGroup.CoordinatesProperty(
+                        latitude="latitude",
+                        longitude="longitude"
+                    ),
+                    local_zone_group="localZoneGroup"
+                ),
                 health_check_id="healthCheckId",
                 hosted_zone_id="hostedZoneId",
                 hosted_zone_name="hostedZoneName",
@@ -3826,7 +4054,8 @@ class CfnRecordSetGroup(
     @builtins.property
     @jsii.member(jsii_name="attrId")
     def attr_id(self) -> builtins.str:
-        '''
+        '''Specifies a coordinate of the east–west position of a geographic point on the surface of the Earth.
+
         :cloudformationAttribute: Id
         '''
         return typing.cast(builtins.str, jsii.get(self, "attrId"))
@@ -4170,6 +4399,72 @@ class CfnRecordSetGroup(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_route53.CfnRecordSetGroup.CoordinatesProperty",
+        jsii_struct_bases=[],
+        name_mapping={"latitude": "latitude", "longitude": "longitude"},
+    )
+    class CoordinatesProperty:
+        def __init__(self, *, latitude: builtins.str, longitude: builtins.str) -> None:
+            '''A complex type that lists the coordinates for a geoproximity resource record.
+
+            :param latitude: Specifies a coordinate of the north–south position of a geographic point on the surface of the Earth (-90 - 90).
+            :param longitude: Specifies a coordinate of the east–west position of a geographic point on the surface of the Earth (-180 - 180).
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53-recordsetgroup-coordinates.html
+            :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
+                
+                coordinates_property = route53.CfnRecordSetGroup.CoordinatesProperty(
+                    latitude="latitude",
+                    longitude="longitude"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__3ebaae8a752b3b1dfff4bf671352e45cbd7c98fa0058ccfb5170085a3e53f8cb)
+                check_type(argname="argument latitude", value=latitude, expected_type=type_hints["latitude"])
+                check_type(argname="argument longitude", value=longitude, expected_type=type_hints["longitude"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "latitude": latitude,
+                "longitude": longitude,
+            }
+
+        @builtins.property
+        def latitude(self) -> builtins.str:
+            '''Specifies a coordinate of the north–south position of a geographic point on the surface of the Earth (-90 - 90).
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53-recordsetgroup-coordinates.html#cfn-route53-recordsetgroup-coordinates-latitude
+            '''
+            result = self._values.get("latitude")
+            assert result is not None, "Required property 'latitude' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def longitude(self) -> builtins.str:
+            '''Specifies a coordinate of the east–west position of a geographic point on the surface of the Earth (-180 - 180).
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53-recordsetgroup-coordinates.html#cfn-route53-recordsetgroup-coordinates-longitude
+            '''
+            result = self._values.get("longitude")
+            assert result is not None, "Required property 'longitude' 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 "CoordinatesProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_route53.CfnRecordSetGroup.GeoLocationProperty",
         jsii_struct_bases=[],
@@ -4275,6 +4570,131 @@ class CfnRecordSetGroup(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_route53.CfnRecordSetGroup.GeoProximityLocationProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "aws_region": "awsRegion",
+            "bias": "bias",
+            "coordinates": "coordinates",
+            "local_zone_group": "localZoneGroup",
+        },
+    )
+    class GeoProximityLocationProperty:
+        def __init__(
+            self,
+            *,
+            aws_region: typing.Optional[builtins.str] = None,
+            bias: typing.Optional[jsii.Number] = None,
+            coordinates: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnRecordSetGroup.CoordinatesProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            local_zone_group: typing.Optional[builtins.str] = None,
+        ) -> None:
+            '''(Resource record sets only): A complex type that lets you specify where your resources are located.
+
+            Only one of ``LocalZoneGroup`` , ``Coordinates`` , or ``AWS Region`` is allowed per request at a time.
+
+            For more information about geoproximity routing, see `Geoproximity routing <https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-geoproximity.html>`_ in the *Amazon Route 53 Developer Guide* .
+
+            :param aws_region: The AWS Region the resource you are directing DNS traffic to, is in.
+            :param bias: The bias increases or decreases the size of the geographic region from which Route 53 routes traffic to a resource. To use ``Bias`` to change the size of the geographic region, specify the applicable value for the bias: - To expand the size of the geographic region from which Route 53 routes traffic to a resource, specify a positive integer from 1 to 99 for the bias. Route 53 shrinks the size of adjacent regions. - To shrink the size of the geographic region from which Route 53 routes traffic to a resource, specify a negative bias of -1 to -99. Route 53 expands the size of adjacent regions.
+            :param coordinates: Contains the longitude and latitude for a geographic region.
+            :param local_zone_group: Specifies an AWS Local Zone Group. A local Zone Group is usually the Local Zone code without the ending character. For example, if the Local Zone is ``us-east-1-bue-1a`` the Local Zone Group is ``us-east-1-bue-1`` . You can identify the Local Zones Group for a specific Local Zone by using the `describe-availability-zones <https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-availability-zones.html>`_ CLI command: This command returns: ``"GroupName": "us-west-2-den-1"`` , specifying that the Local Zone ``us-west-2-den-1a`` belongs to the Local Zone Group ``us-west-2-den-1`` .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53-recordsetgroup-geoproximitylocation.html
+            :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
+                
+                geo_proximity_location_property = route53.CfnRecordSetGroup.GeoProximityLocationProperty(
+                    aws_region="awsRegion",
+                    bias=123,
+                    coordinates=route53.CfnRecordSetGroup.CoordinatesProperty(
+                        latitude="latitude",
+                        longitude="longitude"
+                    ),
+                    local_zone_group="localZoneGroup"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__5430af5a2d4636b1244b53f4c6759f6d1ffde530908e449cf4bc90b0d9de5ec8)
+                check_type(argname="argument aws_region", value=aws_region, expected_type=type_hints["aws_region"])
+                check_type(argname="argument bias", value=bias, expected_type=type_hints["bias"])
+                check_type(argname="argument coordinates", value=coordinates, expected_type=type_hints["coordinates"])
+                check_type(argname="argument local_zone_group", value=local_zone_group, expected_type=type_hints["local_zone_group"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if aws_region is not None:
+                self._values["aws_region"] = aws_region
+            if bias is not None:
+                self._values["bias"] = bias
+            if coordinates is not None:
+                self._values["coordinates"] = coordinates
+            if local_zone_group is not None:
+                self._values["local_zone_group"] = local_zone_group
+
+        @builtins.property
+        def aws_region(self) -> typing.Optional[builtins.str]:
+            '''The AWS Region the resource you are directing DNS traffic to, is in.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53-recordsetgroup-geoproximitylocation.html#cfn-route53-recordsetgroup-geoproximitylocation-awsregion
+            '''
+            result = self._values.get("aws_region")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def bias(self) -> typing.Optional[jsii.Number]:
+            '''The bias increases or decreases the size of the geographic region from which Route 53 routes traffic to a resource.
+
+            To use ``Bias`` to change the size of the geographic region, specify the applicable value for the bias:
+
+            - To expand the size of the geographic region from which Route 53 routes traffic to a resource, specify a positive integer from 1 to 99 for the bias. Route 53 shrinks the size of adjacent regions.
+            - To shrink the size of the geographic region from which Route 53 routes traffic to a resource, specify a negative bias of -1 to -99. Route 53 expands the size of adjacent regions.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53-recordsetgroup-geoproximitylocation.html#cfn-route53-recordsetgroup-geoproximitylocation-bias
+            '''
+            result = self._values.get("bias")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def coordinates(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnRecordSetGroup.CoordinatesProperty"]]:
+            '''Contains the longitude and latitude for a geographic region.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53-recordsetgroup-geoproximitylocation.html#cfn-route53-recordsetgroup-geoproximitylocation-coordinates
+            '''
+            result = self._values.get("coordinates")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnRecordSetGroup.CoordinatesProperty"]], result)
+
+        @builtins.property
+        def local_zone_group(self) -> typing.Optional[builtins.str]:
+            '''Specifies an AWS Local Zone Group.
+
+            A local Zone Group is usually the Local Zone code without the ending character. For example, if the Local Zone is ``us-east-1-bue-1a`` the Local Zone Group is ``us-east-1-bue-1`` .
+
+            You can identify the Local Zones Group for a specific Local Zone by using the `describe-availability-zones <https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-availability-zones.html>`_ CLI command:
+
+            This command returns: ``"GroupName": "us-west-2-den-1"`` , specifying that the Local Zone ``us-west-2-den-1a`` belongs to the Local Zone Group ``us-west-2-den-1`` .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53-recordsetgroup-geoproximitylocation.html#cfn-route53-recordsetgroup-geoproximitylocation-localzonegroup
+            '''
+            result = self._values.get("local_zone_group")
+            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 "GeoProximityLocationProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_route53.CfnRecordSetGroup.RecordSetProperty",
         jsii_struct_bases=[],
@@ -4285,6 +4705,7 @@ class CfnRecordSetGroup(
             "cidr_routing_config": "cidrRoutingConfig",
             "failover": "failover",
             "geo_location": "geoLocation",
+            "geo_proximity_location": "geoProximityLocation",
             "health_check_id": "healthCheckId",
             "hosted_zone_id": "hostedZoneId",
             "hosted_zone_name": "hostedZoneName",
@@ -4306,6 +4727,7 @@ class CfnRecordSetGroup(
             cidr_routing_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnRecordSetGroup.CidrRoutingConfigProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
             failover: typing.Optional[builtins.str] = None,
             geo_location: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnRecordSetGroup.GeoLocationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            geo_proximity_location: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnRecordSetGroup.GeoProximityLocationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
             health_check_id: typing.Optional[builtins.str] = None,
             hosted_zone_id: typing.Optional[builtins.str] = None,
             hosted_zone_name: typing.Optional[builtins.str] = None,
@@ -4324,6 +4746,7 @@ class CfnRecordSetGroup(
             :param cidr_routing_config: 
             :param failover: *Failover resource record sets only:* To configure failover, you add the ``Failover`` element to two resource record sets. For one resource record set, you specify ``PRIMARY`` as the value for ``Failover`` ; for the other resource record set, you specify ``SECONDARY`` . In addition, you include the ``HealthCheckId`` element and specify the health check that you want Amazon Route 53 to perform for each resource record set. Except where noted, the following failover behaviors assume that you have included the ``HealthCheckId`` element in both resource record sets: - When the primary resource record set is healthy, Route 53 responds to DNS queries with the applicable value from the primary resource record set regardless of the health of the secondary resource record set. - When the primary resource record set is unhealthy and the secondary resource record set is healthy, Route 53 responds to DNS queries with the applicable value from the secondary resource record set. - When the secondary resource record set is unhealthy, Route 53 responds to DNS queries with the applicable value from the primary resource record set regardless of the health of the primary resource record set. - If you omit the ``HealthCheckId`` element for the secondary resource record set, and if the primary resource record set is unhealthy, Route 53 always responds to DNS queries with the applicable value from the secondary resource record set. This is true regardless of the health of the associated endpoint. You can't create non-failover resource record sets that have the same values for the ``Name`` and ``Type`` elements as failover resource record sets. For failover alias resource record sets, you must also include the ``EvaluateTargetHealth`` element and set the value to true. For more information about configuring failover for Route 53, see the following topics in the *Amazon Route 53 Developer Guide* : - `Route 53 Health Checks and DNS Failover <https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover.html>`_ - `Configuring Failover in a Private Hosted Zone <https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-private-hosted-zones.html>`_
             :param geo_location: *Geolocation resource record sets only:* A complex type that lets you control how Amazon Route 53 responds to DNS queries based on the geographic origin of the query. For example, if you want all queries from Africa to be routed to a web server with an IP address of ``192.0.2.111`` , create a resource record set with a ``Type`` of ``A`` and a ``ContinentCode`` of ``AF`` . If you create separate resource record sets for overlapping geographic regions (for example, one resource record set for a continent and one for a country on the same continent), priority goes to the smallest geographic region. This allows you to route most queries for a continent to one resource and to route queries for a country on that continent to a different resource. You can't create two geolocation resource record sets that specify the same geographic location. The value ``*`` in the ``CountryCode`` element matches all geographic locations that aren't specified in other geolocation resource record sets that have the same values for the ``Name`` and ``Type`` elements. .. epigraph:: Geolocation works by mapping IP addresses to locations. However, some IP addresses aren't mapped to geographic locations, so even if you create geolocation resource record sets that cover all seven continents, Route 53 will receive some DNS queries from locations that it can't identify. We recommend that you create a resource record set for which the value of ``CountryCode`` is ``*`` . Two groups of queries are routed to the resource that you specify in this record: queries that come from locations for which you haven't created geolocation resource record sets and queries from IP addresses that aren't mapped to a location. If you don't create a ``*`` resource record set, Route 53 returns a "no answer" response for queries from those locations. You can't create non-geolocation resource record sets that have the same values for the ``Name`` and ``Type`` elements as geolocation resource record sets.
+            :param geo_proximity_location: A complex type that contains information about a geographic location.
             :param health_check_id: If you want Amazon Route 53 to return this resource record set in response to a DNS query only when the status of a health check is healthy, include the ``HealthCheckId`` element and specify the ID of the applicable health check. Route 53 determines whether a resource record set is healthy based on one of the following: - By periodically sending a request to the endpoint that is specified in the health check - By aggregating the status of a specified group of health checks (calculated health checks) - By determining the current state of a CloudWatch alarm (CloudWatch metric health checks) .. epigraph:: Route 53 doesn't check the health of the endpoint that is specified in the resource record set, for example, the endpoint specified by the IP address in the ``Value`` element. When you add a ``HealthCheckId`` element to a resource record set, Route 53 checks the health of the endpoint that you specified in the health check. For more information, see the following topics in the *Amazon Route 53 Developer Guide* : - `How Amazon Route 53 Determines Whether an Endpoint Is Healthy <https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-determining-health-of-endpoints.html>`_ - `Route 53 Health Checks and DNS Failover <https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover.html>`_ - `Configuring Failover in a Private Hosted Zone <https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-private-hosted-zones.html>`_ *When to Specify HealthCheckId* Specifying a value for ``HealthCheckId`` is useful only when Route 53 is choosing between two or more resource record sets to respond to a DNS query, and you want Route 53 to base the choice in part on the status of a health check. Configuring health checks makes sense only in the following configurations: - *Non-alias resource record sets* : You're checking the health of a group of non-alias resource record sets that have the same routing policy, name, and type (such as multiple weighted records named www.example.com with a type of A) and you specify health check IDs for all the resource record sets. If the health check status for a resource record set is healthy, Route 53 includes the record among the records that it responds to DNS queries with. If the health check status for a resource record set is unhealthy, Route 53 stops responding to DNS queries using the value for that resource record set. If the health check status for all resource record sets in the group is unhealthy, Route 53 considers all resource record sets in the group healthy and responds to DNS queries accordingly. - *Alias resource record sets* : You specify the following settings: - You set ``EvaluateTargetHealth`` to true for an alias resource record set in a group of resource record sets that have the same routing policy, name, and type (such as multiple weighted records named www.example.com with a type of A). - You configure the alias resource record set to route traffic to a non-alias resource record set in the same hosted zone. - You specify a health check ID for the non-alias resource record set. If the health check status is healthy, Route 53 considers the alias resource record set to be healthy and includes the alias record among the records that it responds to DNS queries with. If the health check status is unhealthy, Route 53 stops responding to DNS queries using the alias resource record set. .. epigraph:: The alias resource record set can also route traffic to a *group* of non-alias resource record sets that have the same routing policy, name, and type. In that configuration, associate health checks with all of the resource record sets in the group of non-alias resource record sets. *Geolocation Routing* For geolocation resource record sets, if an endpoint is unhealthy, Route 53 looks for a resource record set for the larger, associated geographic region. For example, suppose you have resource record sets for a state in the United States, for the entire United States, for North America, and a resource record set that has ``*`` for ``CountryCode`` is ``*`` , which applies to all locations. If the endpoint for the state resource record set is unhealthy, Route 53 checks for healthy resource record sets in the following order until it finds a resource record set for which the endpoint is healthy: - The United States - North America - The default resource record set *Specifying the Health Check Endpoint by Domain Name* If your health checks specify the endpoint only by domain name, we recommend that you create a separate health check for each endpoint. For example, create a health check for each ``HTTP`` server that is serving content for ``www.example.com`` . For the value of ``FullyQualifiedDomainName`` , specify the domain name of the server (such as ``us-east-2-www.example.com`` ), not the name of the resource record sets ( ``www.example.com`` ). .. epigraph:: Health check results will be unpredictable if you do the following: - Create a health check that has the same value for ``FullyQualifiedDomainName`` as the name of a resource record set. - Associate that health check with the resource record set.
             :param hosted_zone_id: The ID of the hosted zone that you want to create records in. Specify either ``HostedZoneName`` or ``HostedZoneId`` , but not both. If you have multiple hosted zones with the same domain name, you must specify the hosted zone using ``HostedZoneId`` . Do not provide the ``HostedZoneId`` if it is already defined in ``AWS::Route53::RecordSetGroup`` . The creation fails if ``HostedZoneId`` is defined in both.
             :param hosted_zone_name: The name of the hosted zone that you want to create records in. You must include a trailing dot (for example, ``www.example.com.`` ) as part of the ``HostedZoneName`` . When you create a stack using an ``AWS::Route53::RecordSet`` that specifies ``HostedZoneName`` , AWS CloudFormation attempts to find a hosted zone whose name matches the ``HostedZoneName`` . If AWS CloudFormation can't find a hosted zone with a matching domain name, or if there is more than one hosted zone with the specified domain name, AWS CloudFormation will not create the stack. Specify either ``HostedZoneName`` or ``HostedZoneId`` , but not both. If you have multiple hosted zones with the same domain name, you must specify the hosted zone using ``HostedZoneId`` .
@@ -4365,6 +4788,15 @@ class CfnRecordSetGroup(
                         country_code="countryCode",
                         subdivision_code="subdivisionCode"
                     ),
+                    geo_proximity_location=route53.CfnRecordSetGroup.GeoProximityLocationProperty(
+                        aws_region="awsRegion",
+                        bias=123,
+                        coordinates=route53.CfnRecordSetGroup.CoordinatesProperty(
+                            latitude="latitude",
+                            longitude="longitude"
+                        ),
+                        local_zone_group="localZoneGroup"
+                    ),
                     health_check_id="healthCheckId",
                     hosted_zone_id="hostedZoneId",
                     hosted_zone_name="hostedZoneName",
@@ -4384,6 +4816,7 @@ class CfnRecordSetGroup(
                 check_type(argname="argument cidr_routing_config", value=cidr_routing_config, expected_type=type_hints["cidr_routing_config"])
                 check_type(argname="argument failover", value=failover, expected_type=type_hints["failover"])
                 check_type(argname="argument geo_location", value=geo_location, expected_type=type_hints["geo_location"])
+                check_type(argname="argument geo_proximity_location", value=geo_proximity_location, expected_type=type_hints["geo_proximity_location"])
                 check_type(argname="argument health_check_id", value=health_check_id, expected_type=type_hints["health_check_id"])
                 check_type(argname="argument hosted_zone_id", value=hosted_zone_id, expected_type=type_hints["hosted_zone_id"])
                 check_type(argname="argument hosted_zone_name", value=hosted_zone_name, expected_type=type_hints["hosted_zone_name"])
@@ -4405,6 +4838,8 @@ class CfnRecordSetGroup(
                 self._values["failover"] = failover
             if geo_location is not None:
                 self._values["geo_location"] = geo_location
+            if geo_proximity_location is not None:
+                self._values["geo_proximity_location"] = geo_proximity_location
             if health_check_id is not None:
                 self._values["health_check_id"] = health_check_id
             if hosted_zone_id is not None:
@@ -4567,6 +5002,17 @@ class CfnRecordSetGroup(
             result = self._values.get("geo_location")
             return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnRecordSetGroup.GeoLocationProperty"]], result)
 
+        @builtins.property
+        def geo_proximity_location(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnRecordSetGroup.GeoProximityLocationProperty"]]:
+            '''A complex type that contains information about a geographic location.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53-recordsetgroup-recordset.html#cfn-route53-recordsetgroup-recordset-geoproximitylocation
+            '''
+            result = self._values.get("geo_proximity_location")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnRecordSetGroup.GeoProximityLocationProperty"]], result)
+
         @builtins.property
         def health_check_id(self) -> typing.Optional[builtins.str]:
             '''If you want Amazon Route 53 to return this resource record set in response to a DNS query only when the status of a health check is healthy, include the ``HealthCheckId`` element and specify the ID of the applicable health check.
@@ -4832,6 +5278,15 @@ class CfnRecordSetGroupProps:
                         country_code="countryCode",
                         subdivision_code="subdivisionCode"
                     ),
+                    geo_proximity_location=route53.CfnRecordSetGroup.GeoProximityLocationProperty(
+                        aws_region="awsRegion",
+                        bias=123,
+                        coordinates=route53.CfnRecordSetGroup.CoordinatesProperty(
+                            latitude="latitude",
+                            longitude="longitude"
+                        ),
+                        local_zone_group="localZoneGroup"
+                    ),
                     health_check_id="healthCheckId",
                     hosted_zone_id="hostedZoneId",
                     hosted_zone_name="hostedZoneName",
@@ -4929,6 +5384,7 @@ class CfnRecordSetGroupProps:
         "comment": "comment",
         "failover": "failover",
         "geo_location": "geoLocation",
+        "geo_proximity_location": "geoProximityLocation",
         "health_check_id": "healthCheckId",
         "hosted_zone_id": "hostedZoneId",
         "hosted_zone_name": "hostedZoneName",
@@ -4951,6 +5407,7 @@ class CfnRecordSetProps:
         comment: typing.Optional[builtins.str] = None,
         failover: typing.Optional[builtins.str] = None,
         geo_location: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnRecordSet.GeoLocationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+        geo_proximity_location: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnRecordSet.GeoProximityLocationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
         health_check_id: typing.Optional[builtins.str] = None,
         hosted_zone_id: typing.Optional[builtins.str] = None,
         hosted_zone_name: typing.Optional[builtins.str] = None,
@@ -4970,6 +5427,7 @@ class CfnRecordSetProps:
         :param comment: *Optional:* Any comments you want to include about a change batch request.
         :param failover: *Failover resource record sets only:* To configure failover, you add the ``Failover`` element to two resource record sets. For one resource record set, you specify ``PRIMARY`` as the value for ``Failover`` ; for the other resource record set, you specify ``SECONDARY`` . In addition, you include the ``HealthCheckId`` element and specify the health check that you want Amazon Route 53 to perform for each resource record set. Except where noted, the following failover behaviors assume that you have included the ``HealthCheckId`` element in both resource record sets: - When the primary resource record set is healthy, Route 53 responds to DNS queries with the applicable value from the primary resource record set regardless of the health of the secondary resource record set. - When the primary resource record set is unhealthy and the secondary resource record set is healthy, Route 53 responds to DNS queries with the applicable value from the secondary resource record set. - When the secondary resource record set is unhealthy, Route 53 responds to DNS queries with the applicable value from the primary resource record set regardless of the health of the primary resource record set. - If you omit the ``HealthCheckId`` element for the secondary resource record set, and if the primary resource record set is unhealthy, Route 53 always responds to DNS queries with the applicable value from the secondary resource record set. This is true regardless of the health of the associated endpoint. You can't create non-failover resource record sets that have the same values for the ``Name`` and ``Type`` elements as failover resource record sets. For failover alias resource record sets, you must also include the ``EvaluateTargetHealth`` element and set the value to true. For more information about configuring failover for Route 53, see the following topics in the *Amazon Route 53 Developer Guide* : - `Route 53 Health Checks and DNS Failover <https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover.html>`_ - `Configuring Failover in a Private Hosted Zone <https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-private-hosted-zones.html>`_
         :param geo_location: *Geolocation resource record sets only:* A complex type that lets you control how Amazon Route 53 responds to DNS queries based on the geographic origin of the query. For example, if you want all queries from Africa to be routed to a web server with an IP address of ``192.0.2.111`` , create a resource record set with a ``Type`` of ``A`` and a ``ContinentCode`` of ``AF`` . If you create separate resource record sets for overlapping geographic regions (for example, one resource record set for a continent and one for a country on the same continent), priority goes to the smallest geographic region. This allows you to route most queries for a continent to one resource and to route queries for a country on that continent to a different resource. You can't create two geolocation resource record sets that specify the same geographic location. The value ``*`` in the ``CountryCode`` element matches all geographic locations that aren't specified in other geolocation resource record sets that have the same values for the ``Name`` and ``Type`` elements. .. epigraph:: Geolocation works by mapping IP addresses to locations. However, some IP addresses aren't mapped to geographic locations, so even if you create geolocation resource record sets that cover all seven continents, Route 53 will receive some DNS queries from locations that it can't identify. We recommend that you create a resource record set for which the value of ``CountryCode`` is ``*`` . Two groups of queries are routed to the resource that you specify in this record: queries that come from locations for which you haven't created geolocation resource record sets and queries from IP addresses that aren't mapped to a location. If you don't create a ``*`` resource record set, Route 53 returns a "no answer" response for queries from those locations. You can't create non-geolocation resource record sets that have the same values for the ``Name`` and ``Type`` elements as geolocation resource record sets.
+        :param geo_proximity_location: *GeoproximityLocation resource record sets only:* A complex type that lets you control how Route 53 responds to DNS queries based on the geographic origin of the query and your resources.
         :param health_check_id: If you want Amazon Route 53 to return this resource record set in response to a DNS query only when the status of a health check is healthy, include the ``HealthCheckId`` element and specify the ID of the applicable health check. Route 53 determines whether a resource record set is healthy based on one of the following: - By periodically sending a request to the endpoint that is specified in the health check - By aggregating the status of a specified group of health checks (calculated health checks) - By determining the current state of a CloudWatch alarm (CloudWatch metric health checks) .. epigraph:: Route 53 doesn't check the health of the endpoint that is specified in the resource record set, for example, the endpoint specified by the IP address in the ``Value`` element. When you add a ``HealthCheckId`` element to a resource record set, Route 53 checks the health of the endpoint that you specified in the health check. For more information, see the following topics in the *Amazon Route 53 Developer Guide* : - `How Amazon Route 53 Determines Whether an Endpoint Is Healthy <https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-determining-health-of-endpoints.html>`_ - `Route 53 Health Checks and DNS Failover <https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover.html>`_ - `Configuring Failover in a Private Hosted Zone <https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-private-hosted-zones.html>`_ *When to Specify HealthCheckId* Specifying a value for ``HealthCheckId`` is useful only when Route 53 is choosing between two or more resource record sets to respond to a DNS query, and you want Route 53 to base the choice in part on the status of a health check. Configuring health checks makes sense only in the following configurations: - *Non-alias resource record sets* : You're checking the health of a group of non-alias resource record sets that have the same routing policy, name, and type (such as multiple weighted records named www.example.com with a type of A) and you specify health check IDs for all the resource record sets. If the health check status for a resource record set is healthy, Route 53 includes the record among the records that it responds to DNS queries with. If the health check status for a resource record set is unhealthy, Route 53 stops responding to DNS queries using the value for that resource record set. If the health check status for all resource record sets in the group is unhealthy, Route 53 considers all resource record sets in the group healthy and responds to DNS queries accordingly. - *Alias resource record sets* : You specify the following settings: - You set ``EvaluateTargetHealth`` to true for an alias resource record set in a group of resource record sets that have the same routing policy, name, and type (such as multiple weighted records named www.example.com with a type of A). - You configure the alias resource record set to route traffic to a non-alias resource record set in the same hosted zone. - You specify a health check ID for the non-alias resource record set. If the health check status is healthy, Route 53 considers the alias resource record set to be healthy and includes the alias record among the records that it responds to DNS queries with. If the health check status is unhealthy, Route 53 stops responding to DNS queries using the alias resource record set. .. epigraph:: The alias resource record set can also route traffic to a *group* of non-alias resource record sets that have the same routing policy, name, and type. In that configuration, associate health checks with all of the resource record sets in the group of non-alias resource record sets. *Geolocation Routing* For geolocation resource record sets, if an endpoint is unhealthy, Route 53 looks for a resource record set for the larger, associated geographic region. For example, suppose you have resource record sets for a state in the United States, for the entire United States, for North America, and a resource record set that has ``*`` for ``CountryCode`` is ``*`` , which applies to all locations. If the endpoint for the state resource record set is unhealthy, Route 53 checks for healthy resource record sets in the following order until it finds a resource record set for which the endpoint is healthy: - The United States - North America - The default resource record set *Specifying the Health Check Endpoint by Domain Name* If your health checks specify the endpoint only by domain name, we recommend that you create a separate health check for each endpoint. For example, create a health check for each ``HTTP`` server that is serving content for ``www.example.com`` . For the value of ``FullyQualifiedDomainName`` , specify the domain name of the server (such as ``us-east-2-www.example.com`` ), not the name of the resource record sets ( ``www.example.com`` ). .. epigraph:: Health check results will be unpredictable if you do the following: - Create a health check that has the same value for ``FullyQualifiedDomainName`` as the name of a resource record set. - Associate that health check with the resource record set.
         :param hosted_zone_id: The ID of the hosted zone that you want to create records in. Specify either ``HostedZoneName`` or ``HostedZoneId`` , but not both. If you have multiple hosted zones with the same domain name, you must specify the hosted zone using ``HostedZoneId`` .
         :param hosted_zone_name: The name of the hosted zone that you want to create records in. You must include a trailing dot (for example, ``www.example.com.`` ) as part of the ``HostedZoneName`` . When you create a stack using an AWS::Route53::RecordSet that specifies ``HostedZoneName`` , AWS CloudFormation attempts to find a hosted zone whose name matches the HostedZoneName. If AWS CloudFormation cannot find a hosted zone with a matching domain name, or if there is more than one hosted zone with the specified domain name, AWS CloudFormation will not create the stack. Specify either ``HostedZoneName`` or ``HostedZoneId`` , but not both. If you have multiple hosted zones with the same domain name, you must specify the hosted zone using ``HostedZoneId`` .
@@ -5012,6 +5470,15 @@ class CfnRecordSetProps:
                     country_code="countryCode",
                     subdivision_code="subdivisionCode"
                 ),
+                geo_proximity_location=route53.CfnRecordSet.GeoProximityLocationProperty(
+                    aws_region="awsRegion",
+                    bias=123,
+                    coordinates=route53.CfnRecordSet.CoordinatesProperty(
+                        latitude="latitude",
+                        longitude="longitude"
+                    ),
+                    local_zone_group="localZoneGroup"
+                ),
                 health_check_id="healthCheckId",
                 hosted_zone_id="hostedZoneId",
                 hosted_zone_name="hostedZoneName",
@@ -5032,6 +5499,7 @@ class CfnRecordSetProps:
             check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
             check_type(argname="argument failover", value=failover, expected_type=type_hints["failover"])
             check_type(argname="argument geo_location", value=geo_location, expected_type=type_hints["geo_location"])
+            check_type(argname="argument geo_proximity_location", value=geo_proximity_location, expected_type=type_hints["geo_proximity_location"])
             check_type(argname="argument health_check_id", value=health_check_id, expected_type=type_hints["health_check_id"])
             check_type(argname="argument hosted_zone_id", value=hosted_zone_id, expected_type=type_hints["hosted_zone_id"])
             check_type(argname="argument hosted_zone_name", value=hosted_zone_name, expected_type=type_hints["hosted_zone_name"])
@@ -5055,6 +5523,8 @@ class CfnRecordSetProps:
             self._values["failover"] = failover
         if geo_location is not None:
             self._values["geo_location"] = geo_location
+        if geo_proximity_location is not None:
+            self._values["geo_proximity_location"] = geo_proximity_location
         if health_check_id is not None:
             self._values["health_check_id"] = health_check_id
         if hosted_zone_id is not None:
@@ -5229,6 +5699,17 @@ class CfnRecordSetProps:
         result = self._values.get("geo_location")
         return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnRecordSet.GeoLocationProperty]], result)
 
+    @builtins.property
+    def geo_proximity_location(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnRecordSet.GeoProximityLocationProperty]]:
+        '''*GeoproximityLocation resource record sets only:* A complex type that lets you control how Route 53 responds to DNS queries based on the geographic origin of the query and your resources.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-route53-recordset.html#cfn-route53-recordset-geoproximitylocation
+        '''
+        result = self._values.get("geo_proximity_location")
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnRecordSet.GeoProximityLocationProperty]], result)
+
     @builtins.property
     def health_check_id(self) -> typing.Optional[builtins.str]:
         '''If you want Amazon Route 53 to return this resource record set in response to a DNS query only when the status of a health check is healthy, include the ``HealthCheckId`` element and specify the ID of the applicable health check.
@@ -12502,6 +12983,7 @@ def _typecheckingstub__5260f62d2297374b2126da361d614f7922d306048a751f4287d4f7b25
     comment: typing.Optional[builtins.str] = None,
     failover: typing.Optional[builtins.str] = None,
     geo_location: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnRecordSet.GeoLocationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    geo_proximity_location: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnRecordSet.GeoProximityLocationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     health_check_id: typing.Optional[builtins.str] = None,
     hosted_zone_id: typing.Optional[builtins.str] = None,
     hosted_zone_name: typing.Optional[builtins.str] = None,
@@ -12569,6 +13051,12 @@ def _typecheckingstub__e7b257b8973ecbc1eff717cef5d9e9a86a7e93521a1f67acf22b2e846
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__ac8d1aee0fc5c4e2eba653391bb8b61826a08b6708db398bae5b22b4e13fcf05(
+    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnRecordSet.GeoProximityLocationProperty]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__6008831249a60a522c31e8ed28371a87feee29b69976deadfbbb7939c49e5a0a(
     value: typing.Optional[builtins.str],
 ) -> None:
@@ -12640,6 +13128,14 @@ def _typecheckingstub__cc6569566583d30a42a983532b11cef6d6313d0666f46f50d599eabd1
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__29683fc8d824969c71955a00cda4d10dde445180eb16e6a17c990ec1252a893a(
+    *,
+    latitude: builtins.str,
+    longitude: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__fc6e59779782a9e8ecceda7a67dfa9c21d257bdac8db0558def7239dd1d167a5(
     *,
     continent_code: typing.Optional[builtins.str] = None,
@@ -12649,6 +13145,16 @@ def _typecheckingstub__fc6e59779782a9e8ecceda7a67dfa9c21d257bdac8db0558def7239dd
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__9bbef31bd9d19fea78e067206e8cea17ada33bda9853588d7a99d66d91f15555(
+    *,
+    aws_region: typing.Optional[builtins.str] = None,
+    bias: typing.Optional[jsii.Number] = None,
+    coordinates: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnRecordSet.CoordinatesProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    local_zone_group: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__88410dc2301961a44d6910ee0de13aa8273ce0fa1b93daca4141c18b5fa3d03b(
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
@@ -12714,6 +13220,14 @@ def _typecheckingstub__c25a6f79ee876d62204e1e24470518bddae21e675bc5258cc7766c8a3
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__3ebaae8a752b3b1dfff4bf671352e45cbd7c98fa0058ccfb5170085a3e53f8cb(
+    *,
+    latitude: builtins.str,
+    longitude: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__2815193fa29c379ea003dd9391a70d63f49989043e7f24e220ccebb1143c1026(
     *,
     continent_code: typing.Optional[builtins.str] = None,
@@ -12723,6 +13237,16 @@ def _typecheckingstub__2815193fa29c379ea003dd9391a70d63f49989043e7f24e220ccebb11
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__5430af5a2d4636b1244b53f4c6759f6d1ffde530908e449cf4bc90b0d9de5ec8(
+    *,
+    aws_region: typing.Optional[builtins.str] = None,
+    bias: typing.Optional[jsii.Number] = None,
+    coordinates: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnRecordSetGroup.CoordinatesProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    local_zone_group: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__11ff291a729fd95a26a222e98e883239191c114a9dd6e70516ac2fe433d4b95d(
     *,
     name: builtins.str,
@@ -12731,6 +13255,7 @@ def _typecheckingstub__11ff291a729fd95a26a222e98e883239191c114a9dd6e70516ac2fe43
     cidr_routing_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnRecordSetGroup.CidrRoutingConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     failover: typing.Optional[builtins.str] = None,
     geo_location: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnRecordSetGroup.GeoLocationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    geo_proximity_location: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnRecordSetGroup.GeoProximityLocationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     health_check_id: typing.Optional[builtins.str] = None,
     hosted_zone_id: typing.Optional[builtins.str] = None,
     hosted_zone_name: typing.Optional[builtins.str] = None,
@@ -12763,6 +13288,7 @@ def _typecheckingstub__07806684fd0bcb683322d42ae67181582216fa4e1371a7133012bf489
     comment: typing.Optional[builtins.str] = None,
     failover: typing.Optional[builtins.str] = None,
     geo_location: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnRecordSet.GeoLocationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    geo_proximity_location: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnRecordSet.GeoProximityLocationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     health_check_id: typing.Optional[builtins.str] = None,
     hosted_zone_id: typing.Optional[builtins.str] = None,
     hosted_zone_name: typing.Optional[builtins.str] = None,