stadiamaps 5.0.0__py3-none-any.whl → 6.1.0__py3-none-any.whl

stadiamaps/api/geocoding_api.py

@@ -5,7 +5,7 @@
 
     The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.
 
-    The version of the OpenAPI document: 8.0.0
+    The version of the OpenAPI document: 9.1.1
     Contact: support@stadiamaps.com
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
@@ -23,8 +23,11 @@ from typing_extensions import Annotated
 from stadiamaps.models.bulk_request import BulkRequest
 from stadiamaps.models.bulk_search_response import BulkSearchResponse
 from stadiamaps.models.geocode_response import GeocodeResponse
+from stadiamaps.models.geocode_response_envelope_properties_v2 import GeocodeResponseEnvelopePropertiesV2
 from stadiamaps.models.geocoding_layer import GeocodingLayer
 from stadiamaps.models.geocoding_source import GeocodingSource
+from stadiamaps.models.layer_id import LayerId
+from stadiamaps.models.source_id import SourceId
 
 from stadiamaps.api_client import ApiClient, RequestSerialized
 from stadiamaps.api_response import ApiResponse
@@ -57,7 +60,7 @@ class GeocodingApi:
         boundary_circle_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The latitude of the center of a circle to limit the search to. Requires `boundary.circle.lon`.")] = None,
         boundary_circle_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The longitude of the center of a circle to limit the search to. Requires `boundary.circle.lat`.")] = None,
         boundary_circle_radius: Annotated[Optional[Union[StrictFloat, StrictInt]], Field(description="The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.")] = None,
-        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.")] = None,
+        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.")] = None,
         boundary_gid: Annotated[Optional[StrictStr], Field(description="The GID of an area to limit the search to.")] = None,
         layers: Annotated[Optional[List[GeocodingLayer]], Field(description="A list of layers to limit the search to.")] = None,
         sources: Annotated[Optional[List[GeocodingSource]], Field(description="A list of sources to limit the search to.")] = None,
@@ -100,7 +103,7 @@ class GeocodingApi:
         :type boundary_circle_lon: float
         :param boundary_circle_radius: The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.
         :type boundary_circle_radius: float
-        :param boundary_country: A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.
+        :param boundary_country: A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.
         :type boundary_country: List[str]
         :param boundary_gid: The GID of an area to limit the search to.
         :type boundary_gid: str
@@ -185,7 +188,7 @@ class GeocodingApi:
         boundary_circle_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The latitude of the center of a circle to limit the search to. Requires `boundary.circle.lon`.")] = None,
         boundary_circle_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The longitude of the center of a circle to limit the search to. Requires `boundary.circle.lat`.")] = None,
         boundary_circle_radius: Annotated[Optional[Union[StrictFloat, StrictInt]], Field(description="The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.")] = None,
-        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.")] = None,
+        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.")] = None,
         boundary_gid: Annotated[Optional[StrictStr], Field(description="The GID of an area to limit the search to.")] = None,
         layers: Annotated[Optional[List[GeocodingLayer]], Field(description="A list of layers to limit the search to.")] = None,
         sources: Annotated[Optional[List[GeocodingSource]], Field(description="A list of sources to limit the search to.")] = None,
@@ -228,7 +231,7 @@ class GeocodingApi:
         :type boundary_circle_lon: float
         :param boundary_circle_radius: The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.
         :type boundary_circle_radius: float
-        :param boundary_country: A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.
+        :param boundary_country: A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.
         :type boundary_country: List[str]
         :param boundary_gid: The GID of an area to limit the search to.
         :type boundary_gid: str
@@ -313,7 +316,7 @@ class GeocodingApi:
         boundary_circle_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The latitude of the center of a circle to limit the search to. Requires `boundary.circle.lon`.")] = None,
         boundary_circle_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The longitude of the center of a circle to limit the search to. Requires `boundary.circle.lat`.")] = None,
         boundary_circle_radius: Annotated[Optional[Union[StrictFloat, StrictInt]], Field(description="The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.")] = None,
-        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.")] = None,
+        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.")] = None,
         boundary_gid: Annotated[Optional[StrictStr], Field(description="The GID of an area to limit the search to.")] = None,
         layers: Annotated[Optional[List[GeocodingLayer]], Field(description="A list of layers to limit the search to.")] = None,
         sources: Annotated[Optional[List[GeocodingSource]], Field(description="A list of sources to limit the search to.")] = None,
@@ -356,7 +359,7 @@ class GeocodingApi:
         :type boundary_circle_lon: float
         :param boundary_circle_radius: The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.
         :type boundary_circle_radius: float
-        :param boundary_country: A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.
+        :param boundary_country: A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.
         :type boundary_country: List[str]
         :param boundary_gid: The GID of an area to limit the search to.
         :type boundary_gid: str
@@ -569,7 +572,675 @@ class GeocodingApi:
 
 
     @validate_call
-    def place(
+    def autocomplete_v2(
+        self,
+        text: Annotated[StrictStr, Field(description="The text to search for (the start of an address, place name, etc.).")],
+        focus_point_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The latitude of a focus point.  If provided (along with longitude), the search results should be more locally relevant.")] = None,
+        focus_point_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The longitude of a focus point.  If provided (along with longitude), the search results should be more locally relevant.")] = None,
+        layers: Annotated[Optional[List[LayerId]], Field(description="A list of layers to limit the search to.")] = None,
+        sources: Annotated[Optional[List[SourceId]], Field(description="A list of sources to limit the search to.")] = None,
+        boundary_gid: Annotated[Optional[StrictStr], Field(description="The GID of a region to limit the search to.  Note: these are not stable for all datasets! For example, OSM features may be deleted and re-added with a new ID.")] = None,
+        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of comma-separated country codes in ISO 3116-1 alpha-2 or alpha-3 format. The search will be limited to these countries.")] = None,
+        boundary_rect_min_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The minimum latitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.")] = None,
+        boundary_rect_min_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The minimum longitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.")] = None,
+        boundary_rect_max_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The maximum latitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.")] = None,
+        boundary_rect_max_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The maximum longitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.")] = None,
+        boundary_circle_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The latitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lon.")] = None,
+        boundary_circle_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The longitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lon.")] = None,
+        boundary_circle_radius: Annotated[Optional[Annotated[int, Field(strict=True, ge=0)]], Field(description="The radius of the circle (in kilometers) to limit the search to.  NOTE: Requires the other boundary.circle parameters to take effect. Defaults to 50km if unspecified.")] = None,
+        size: Annotated[Optional[Annotated[int, Field(le=25, strict=True, ge=1)]], Field(description="The maximum number of items to return from a query.")] = None,
+        lang: Annotated[Optional[StrictStr], Field(description="A BCP47 language tag which specifies a preference for localization of results. There is no default value, so place names will be returned as-is, which is usually in the local language. NOTE: The Accept-Language header is also respected, and many user agents will set it automatically.")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> GeocodeResponseEnvelopePropertiesV2:
+        """autocomplete_v2
+
+
+        :param text: The text to search for (the start of an address, place name, etc.). (required)
+        :type text: str
+        :param focus_point_lat: The latitude of a focus point.  If provided (along with longitude), the search results should be more locally relevant.
+        :type focus_point_lat: float
+        :param focus_point_lon: The longitude of a focus point.  If provided (along with longitude), the search results should be more locally relevant.
+        :type focus_point_lon: float
+        :param layers: A list of layers to limit the search to.
+        :type layers: List[LayerId]
+        :param sources: A list of sources to limit the search to.
+        :type sources: List[SourceId]
+        :param boundary_gid: The GID of a region to limit the search to.  Note: these are not stable for all datasets! For example, OSM features may be deleted and re-added with a new ID.
+        :type boundary_gid: str
+        :param boundary_country: A list of comma-separated country codes in ISO 3116-1 alpha-2 or alpha-3 format. The search will be limited to these countries.
+        :type boundary_country: List[str]
+        :param boundary_rect_min_lat: The minimum latitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.
+        :type boundary_rect_min_lat: float
+        :param boundary_rect_min_lon: The minimum longitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.
+        :type boundary_rect_min_lon: float
+        :param boundary_rect_max_lat: The maximum latitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.
+        :type boundary_rect_max_lat: float
+        :param boundary_rect_max_lon: The maximum longitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.
+        :type boundary_rect_max_lon: float
+        :param boundary_circle_lat: The latitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lon.
+        :type boundary_circle_lat: float
+        :param boundary_circle_lon: The longitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lon.
+        :type boundary_circle_lon: float
+        :param boundary_circle_radius: The radius of the circle (in kilometers) to limit the search to.  NOTE: Requires the other boundary.circle parameters to take effect. Defaults to 50km if unspecified.
+        :type boundary_circle_radius: int
+        :param size: The maximum number of items to return from a query.
+        :type size: int
+        :param lang: A BCP47 language tag which specifies a preference for localization of results. There is no default value, so place names will be returned as-is, which is usually in the local language. NOTE: The Accept-Language header is also respected, and many user agents will set it automatically.
+        :type lang: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._autocomplete_v2_serialize(
+            text=text,
+            focus_point_lat=focus_point_lat,
+            focus_point_lon=focus_point_lon,
+            layers=layers,
+            sources=sources,
+            boundary_gid=boundary_gid,
+            boundary_country=boundary_country,
+            boundary_rect_min_lat=boundary_rect_min_lat,
+            boundary_rect_min_lon=boundary_rect_min_lon,
+            boundary_rect_max_lat=boundary_rect_max_lat,
+            boundary_rect_max_lon=boundary_rect_max_lon,
+            boundary_circle_lat=boundary_circle_lat,
+            boundary_circle_lon=boundary_circle_lon,
+            boundary_circle_radius=boundary_circle_radius,
+            size=size,
+            lang=lang,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "GeocodeResponseEnvelopePropertiesV2",
+            '400': "GeocodeResponseEnvelopePropertiesV2",
+            '500': "GeocodeResponseEnvelopePropertiesV2",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def autocomplete_v2_with_http_info(
+        self,
+        text: Annotated[StrictStr, Field(description="The text to search for (the start of an address, place name, etc.).")],
+        focus_point_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The latitude of a focus point.  If provided (along with longitude), the search results should be more locally relevant.")] = None,
+        focus_point_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The longitude of a focus point.  If provided (along with longitude), the search results should be more locally relevant.")] = None,
+        layers: Annotated[Optional[List[LayerId]], Field(description="A list of layers to limit the search to.")] = None,
+        sources: Annotated[Optional[List[SourceId]], Field(description="A list of sources to limit the search to.")] = None,
+        boundary_gid: Annotated[Optional[StrictStr], Field(description="The GID of a region to limit the search to.  Note: these are not stable for all datasets! For example, OSM features may be deleted and re-added with a new ID.")] = None,
+        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of comma-separated country codes in ISO 3116-1 alpha-2 or alpha-3 format. The search will be limited to these countries.")] = None,
+        boundary_rect_min_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The minimum latitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.")] = None,
+        boundary_rect_min_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The minimum longitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.")] = None,
+        boundary_rect_max_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The maximum latitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.")] = None,
+        boundary_rect_max_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The maximum longitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.")] = None,
+        boundary_circle_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The latitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lon.")] = None,
+        boundary_circle_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The longitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lon.")] = None,
+        boundary_circle_radius: Annotated[Optional[Annotated[int, Field(strict=True, ge=0)]], Field(description="The radius of the circle (in kilometers) to limit the search to.  NOTE: Requires the other boundary.circle parameters to take effect. Defaults to 50km if unspecified.")] = None,
+        size: Annotated[Optional[Annotated[int, Field(le=25, strict=True, ge=1)]], Field(description="The maximum number of items to return from a query.")] = None,
+        lang: Annotated[Optional[StrictStr], Field(description="A BCP47 language tag which specifies a preference for localization of results. There is no default value, so place names will be returned as-is, which is usually in the local language. NOTE: The Accept-Language header is also respected, and many user agents will set it automatically.")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[GeocodeResponseEnvelopePropertiesV2]:
+        """autocomplete_v2
+
+
+        :param text: The text to search for (the start of an address, place name, etc.). (required)
+        :type text: str
+        :param focus_point_lat: The latitude of a focus point.  If provided (along with longitude), the search results should be more locally relevant.
+        :type focus_point_lat: float
+        :param focus_point_lon: The longitude of a focus point.  If provided (along with longitude), the search results should be more locally relevant.
+        :type focus_point_lon: float
+        :param layers: A list of layers to limit the search to.
+        :type layers: List[LayerId]
+        :param sources: A list of sources to limit the search to.
+        :type sources: List[SourceId]
+        :param boundary_gid: The GID of a region to limit the search to.  Note: these are not stable for all datasets! For example, OSM features may be deleted and re-added with a new ID.
+        :type boundary_gid: str
+        :param boundary_country: A list of comma-separated country codes in ISO 3116-1 alpha-2 or alpha-3 format. The search will be limited to these countries.
+        :type boundary_country: List[str]
+        :param boundary_rect_min_lat: The minimum latitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.
+        :type boundary_rect_min_lat: float
+        :param boundary_rect_min_lon: The minimum longitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.
+        :type boundary_rect_min_lon: float
+        :param boundary_rect_max_lat: The maximum latitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.
+        :type boundary_rect_max_lat: float
+        :param boundary_rect_max_lon: The maximum longitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.
+        :type boundary_rect_max_lon: float
+        :param boundary_circle_lat: The latitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lon.
+        :type boundary_circle_lat: float
+        :param boundary_circle_lon: The longitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lon.
+        :type boundary_circle_lon: float
+        :param boundary_circle_radius: The radius of the circle (in kilometers) to limit the search to.  NOTE: Requires the other boundary.circle parameters to take effect. Defaults to 50km if unspecified.
+        :type boundary_circle_radius: int
+        :param size: The maximum number of items to return from a query.
+        :type size: int
+        :param lang: A BCP47 language tag which specifies a preference for localization of results. There is no default value, so place names will be returned as-is, which is usually in the local language. NOTE: The Accept-Language header is also respected, and many user agents will set it automatically.
+        :type lang: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._autocomplete_v2_serialize(
+            text=text,
+            focus_point_lat=focus_point_lat,
+            focus_point_lon=focus_point_lon,
+            layers=layers,
+            sources=sources,
+            boundary_gid=boundary_gid,
+            boundary_country=boundary_country,
+            boundary_rect_min_lat=boundary_rect_min_lat,
+            boundary_rect_min_lon=boundary_rect_min_lon,
+            boundary_rect_max_lat=boundary_rect_max_lat,
+            boundary_rect_max_lon=boundary_rect_max_lon,
+            boundary_circle_lat=boundary_circle_lat,
+            boundary_circle_lon=boundary_circle_lon,
+            boundary_circle_radius=boundary_circle_radius,
+            size=size,
+            lang=lang,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "GeocodeResponseEnvelopePropertiesV2",
+            '400': "GeocodeResponseEnvelopePropertiesV2",
+            '500': "GeocodeResponseEnvelopePropertiesV2",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def autocomplete_v2_without_preload_content(
+        self,
+        text: Annotated[StrictStr, Field(description="The text to search for (the start of an address, place name, etc.).")],
+        focus_point_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The latitude of a focus point.  If provided (along with longitude), the search results should be more locally relevant.")] = None,
+        focus_point_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The longitude of a focus point.  If provided (along with longitude), the search results should be more locally relevant.")] = None,
+        layers: Annotated[Optional[List[LayerId]], Field(description="A list of layers to limit the search to.")] = None,
+        sources: Annotated[Optional[List[SourceId]], Field(description="A list of sources to limit the search to.")] = None,
+        boundary_gid: Annotated[Optional[StrictStr], Field(description="The GID of a region to limit the search to.  Note: these are not stable for all datasets! For example, OSM features may be deleted and re-added with a new ID.")] = None,
+        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of comma-separated country codes in ISO 3116-1 alpha-2 or alpha-3 format. The search will be limited to these countries.")] = None,
+        boundary_rect_min_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The minimum latitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.")] = None,
+        boundary_rect_min_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The minimum longitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.")] = None,
+        boundary_rect_max_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The maximum latitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.")] = None,
+        boundary_rect_max_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The maximum longitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.")] = None,
+        boundary_circle_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The latitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lon.")] = None,
+        boundary_circle_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The longitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lon.")] = None,
+        boundary_circle_radius: Annotated[Optional[Annotated[int, Field(strict=True, ge=0)]], Field(description="The radius of the circle (in kilometers) to limit the search to.  NOTE: Requires the other boundary.circle parameters to take effect. Defaults to 50km if unspecified.")] = None,
+        size: Annotated[Optional[Annotated[int, Field(le=25, strict=True, ge=1)]], Field(description="The maximum number of items to return from a query.")] = None,
+        lang: Annotated[Optional[StrictStr], Field(description="A BCP47 language tag which specifies a preference for localization of results. There is no default value, so place names will be returned as-is, which is usually in the local language. NOTE: The Accept-Language header is also respected, and many user agents will set it automatically.")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """autocomplete_v2
+
+
+        :param text: The text to search for (the start of an address, place name, etc.). (required)
+        :type text: str
+        :param focus_point_lat: The latitude of a focus point.  If provided (along with longitude), the search results should be more locally relevant.
+        :type focus_point_lat: float
+        :param focus_point_lon: The longitude of a focus point.  If provided (along with longitude), the search results should be more locally relevant.
+        :type focus_point_lon: float
+        :param layers: A list of layers to limit the search to.
+        :type layers: List[LayerId]
+        :param sources: A list of sources to limit the search to.
+        :type sources: List[SourceId]
+        :param boundary_gid: The GID of a region to limit the search to.  Note: these are not stable for all datasets! For example, OSM features may be deleted and re-added with a new ID.
+        :type boundary_gid: str
+        :param boundary_country: A list of comma-separated country codes in ISO 3116-1 alpha-2 or alpha-3 format. The search will be limited to these countries.
+        :type boundary_country: List[str]
+        :param boundary_rect_min_lat: The minimum latitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.
+        :type boundary_rect_min_lat: float
+        :param boundary_rect_min_lon: The minimum longitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.
+        :type boundary_rect_min_lon: float
+        :param boundary_rect_max_lat: The maximum latitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.
+        :type boundary_rect_max_lat: float
+        :param boundary_rect_max_lon: The maximum longitude component of a search bounding box.  NOTE: Requires all other boundary.rect parameters to be specified.
+        :type boundary_rect_max_lon: float
+        :param boundary_circle_lat: The latitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lon.
+        :type boundary_circle_lat: float
+        :param boundary_circle_lon: The longitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lon.
+        :type boundary_circle_lon: float
+        :param boundary_circle_radius: The radius of the circle (in kilometers) to limit the search to.  NOTE: Requires the other boundary.circle parameters to take effect. Defaults to 50km if unspecified.
+        :type boundary_circle_radius: int
+        :param size: The maximum number of items to return from a query.
+        :type size: int
+        :param lang: A BCP47 language tag which specifies a preference for localization of results. There is no default value, so place names will be returned as-is, which is usually in the local language. NOTE: The Accept-Language header is also respected, and many user agents will set it automatically.
+        :type lang: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._autocomplete_v2_serialize(
+            text=text,
+            focus_point_lat=focus_point_lat,
+            focus_point_lon=focus_point_lon,
+            layers=layers,
+            sources=sources,
+            boundary_gid=boundary_gid,
+            boundary_country=boundary_country,
+            boundary_rect_min_lat=boundary_rect_min_lat,
+            boundary_rect_min_lon=boundary_rect_min_lon,
+            boundary_rect_max_lat=boundary_rect_max_lat,
+            boundary_rect_max_lon=boundary_rect_max_lon,
+            boundary_circle_lat=boundary_circle_lat,
+            boundary_circle_lon=boundary_circle_lon,
+            boundary_circle_radius=boundary_circle_radius,
+            size=size,
+            lang=lang,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "GeocodeResponseEnvelopePropertiesV2",
+            '400': "GeocodeResponseEnvelopePropertiesV2",
+            '500': "GeocodeResponseEnvelopePropertiesV2",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _autocomplete_v2_serialize(
+        self,
+        text,
+        focus_point_lat,
+        focus_point_lon,
+        layers,
+        sources,
+        boundary_gid,
+        boundary_country,
+        boundary_rect_min_lat,
+        boundary_rect_min_lon,
+        boundary_rect_max_lat,
+        boundary_rect_max_lon,
+        boundary_circle_lat,
+        boundary_circle_lon,
+        boundary_circle_radius,
+        size,
+        lang,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+            'layers': 'csv',
+            'sources': 'csv',
+            'boundary.country': 'csv',
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        # process the query parameters
+        if text is not None:
+            
+            _query_params.append(('text', text))
+            
+        if focus_point_lat is not None:
+            
+            _query_params.append(('focus.point.lat', focus_point_lat))
+            
+        if focus_point_lon is not None:
+            
+            _query_params.append(('focus.point.lon', focus_point_lon))
+            
+        if layers is not None:
+            
+            _query_params.append(('layers', layers))
+            
+        if sources is not None:
+            
+            _query_params.append(('sources', sources))
+            
+        if boundary_gid is not None:
+            
+            _query_params.append(('boundary.gid', boundary_gid))
+            
+        if boundary_country is not None:
+            
+            _query_params.append(('boundary.country', boundary_country))
+            
+        if boundary_rect_min_lat is not None:
+            
+            _query_params.append(('boundary.rect.min_lat', boundary_rect_min_lat))
+            
+        if boundary_rect_min_lon is not None:
+            
+            _query_params.append(('boundary.rect.min_lon', boundary_rect_min_lon))
+            
+        if boundary_rect_max_lat is not None:
+            
+            _query_params.append(('boundary.rect.max_lat', boundary_rect_max_lat))
+            
+        if boundary_rect_max_lon is not None:
+            
+            _query_params.append(('boundary.rect.max_lon', boundary_rect_max_lon))
+            
+        if boundary_circle_lat is not None:
+            
+            _query_params.append(('boundary.circle.lat', boundary_circle_lat))
+            
+        if boundary_circle_lon is not None:
+            
+            _query_params.append(('boundary.circle.lon', boundary_circle_lon))
+            
+        if boundary_circle_radius is not None:
+            
+            _query_params.append(('boundary.circle.radius', boundary_circle_radius))
+            
+        if size is not None:
+            
+            _query_params.append(('size', size))
+            
+        if lang is not None:
+            
+            _query_params.append(('lang', lang))
+            
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'ApiKeyAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/geocoding/v2/autocomplete',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def place_details(
+        self,
+        ids: Annotated[List[StrictStr], Field(description="A list of GIDs to search for.")],
+        lang: Annotated[Optional[StrictStr], Field(description="A BCP47 language tag which specifies a preference for localization of results. By default, results are in the default locale of the source data, but specifying a language will attempt to localize the results. Note that while a `langtag` (in RFC 5646 terms) can contain script, region, etc., only the `language` portion, an ISO 639 code, will be considered. So `en-US` and `en-GB` will both be treated as English.")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> GeocodeResponse:
+        """Retrieve details of a place using its GID.
+
+        Many search result components include an associated GID field (for example, an address may have a `localadmin_gid`). The place endpoint lets you look up these places directly by ID. Note that GIDs are not stable for all sources. See the [online documentation](https://docs.stadiamaps.com/geocoding-search-autocomplete/place-lookup/) for details.
+
+        :param ids: A list of GIDs to search for. (required)
+        :type ids: List[str]
+        :param lang: A BCP47 language tag which specifies a preference for localization of results. By default, results are in the default locale of the source data, but specifying a language will attempt to localize the results. Note that while a `langtag` (in RFC 5646 terms) can contain script, region, etc., only the `language` portion, an ISO 639 code, will be considered. So `en-US` and `en-GB` will both be treated as English.
+        :type lang: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._place_details_serialize(
+            ids=ids,
+            lang=lang,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "GeocodeResponse",
+            '400': None,
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def place_details_with_http_info(
+        self,
+        ids: Annotated[List[StrictStr], Field(description="A list of GIDs to search for.")],
+        lang: Annotated[Optional[StrictStr], Field(description="A BCP47 language tag which specifies a preference for localization of results. By default, results are in the default locale of the source data, but specifying a language will attempt to localize the results. Note that while a `langtag` (in RFC 5646 terms) can contain script, region, etc., only the `language` portion, an ISO 639 code, will be considered. So `en-US` and `en-GB` will both be treated as English.")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[GeocodeResponse]:
+        """Retrieve details of a place using its GID.
+
+        Many search result components include an associated GID field (for example, an address may have a `localadmin_gid`). The place endpoint lets you look up these places directly by ID. Note that GIDs are not stable for all sources. See the [online documentation](https://docs.stadiamaps.com/geocoding-search-autocomplete/place-lookup/) for details.
+
+        :param ids: A list of GIDs to search for. (required)
+        :type ids: List[str]
+        :param lang: A BCP47 language tag which specifies a preference for localization of results. By default, results are in the default locale of the source data, but specifying a language will attempt to localize the results. Note that while a `langtag` (in RFC 5646 terms) can contain script, region, etc., only the `language` portion, an ISO 639 code, will be considered. So `en-US` and `en-GB` will both be treated as English.
+        :type lang: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._place_details_serialize(
+            ids=ids,
+            lang=lang,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "GeocodeResponse",
+            '400': None,
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def place_details_without_preload_content(
         self,
         ids: Annotated[List[StrictStr], Field(description="A list of GIDs to search for.")],
         lang: Annotated[Optional[StrictStr], Field(description="A BCP47 language tag which specifies a preference for localization of results. By default, results are in the default locale of the source data, but specifying a language will attempt to localize the results. Note that while a `langtag` (in RFC 5646 terms) can contain script, region, etc., only the `language` portion, an ISO 639 code, will be considered. So `en-US` and `en-GB` will both be treated as English.")] = None,
@@ -585,13 +1256,458 @@ class GeocodingApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Retrieve details of a place using its GID.
+
+        Many search result components include an associated GID field (for example, an address may have a `localadmin_gid`). The place endpoint lets you look up these places directly by ID. Note that GIDs are not stable for all sources. See the [online documentation](https://docs.stadiamaps.com/geocoding-search-autocomplete/place-lookup/) for details.
+
+        :param ids: A list of GIDs to search for. (required)
+        :type ids: List[str]
+        :param lang: A BCP47 language tag which specifies a preference for localization of results. By default, results are in the default locale of the source data, but specifying a language will attempt to localize the results. Note that while a `langtag` (in RFC 5646 terms) can contain script, region, etc., only the `language` portion, an ISO 639 code, will be considered. So `en-US` and `en-GB` will both be treated as English.
+        :type lang: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._place_details_serialize(
+            ids=ids,
+            lang=lang,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "GeocodeResponse",
+            '400': None,
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _place_details_serialize(
+        self,
+        ids,
+        lang,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+            'ids': 'csv',
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        # process the query parameters
+        if ids is not None:
+            
+            _query_params.append(('ids', ids))
+            
+        if lang is not None:
+            
+            _query_params.append(('lang', lang))
+            
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'ApiKeyAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/geocoding/v1/place',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def place_details_v2(
+        self,
+        ids: List[StrictStr],
+        lang: Annotated[Optional[StrictStr], Field(description="A BCP47 language tag which specifies a preference for localization of results. There is no default value, so place names will be returned as-is, which is usually in the local language. NOTE: The Accept-Language header is also respected, and many user agents will set it automatically.")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> GeocodeResponseEnvelopePropertiesV2:
+        """place_details_v2
+
+
+        :param ids: (required)
+        :type ids: List[str]
+        :param lang: A BCP47 language tag which specifies a preference for localization of results. There is no default value, so place names will be returned as-is, which is usually in the local language. NOTE: The Accept-Language header is also respected, and many user agents will set it automatically.
+        :type lang: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._place_details_v2_serialize(
+            ids=ids,
+            lang=lang,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "GeocodeResponseEnvelopePropertiesV2",
+            '400': "GeocodeResponseEnvelopePropertiesV2",
+            '500': "GeocodeResponseEnvelopePropertiesV2",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def place_details_v2_with_http_info(
+        self,
+        ids: List[StrictStr],
+        lang: Annotated[Optional[StrictStr], Field(description="A BCP47 language tag which specifies a preference for localization of results. There is no default value, so place names will be returned as-is, which is usually in the local language. NOTE: The Accept-Language header is also respected, and many user agents will set it automatically.")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[GeocodeResponseEnvelopePropertiesV2]:
+        """place_details_v2
+
+
+        :param ids: (required)
+        :type ids: List[str]
+        :param lang: A BCP47 language tag which specifies a preference for localization of results. There is no default value, so place names will be returned as-is, which is usually in the local language. NOTE: The Accept-Language header is also respected, and many user agents will set it automatically.
+        :type lang: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._place_details_v2_serialize(
+            ids=ids,
+            lang=lang,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "GeocodeResponseEnvelopePropertiesV2",
+            '400': "GeocodeResponseEnvelopePropertiesV2",
+            '500': "GeocodeResponseEnvelopePropertiesV2",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def place_details_v2_without_preload_content(
+        self,
+        ids: List[StrictStr],
+        lang: Annotated[Optional[StrictStr], Field(description="A BCP47 language tag which specifies a preference for localization of results. There is no default value, so place names will be returned as-is, which is usually in the local language. NOTE: The Accept-Language header is also respected, and many user agents will set it automatically.")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """place_details_v2
+
+
+        :param ids: (required)
+        :type ids: List[str]
+        :param lang: A BCP47 language tag which specifies a preference for localization of results. There is no default value, so place names will be returned as-is, which is usually in the local language. NOTE: The Accept-Language header is also respected, and many user agents will set it automatically.
+        :type lang: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._place_details_v2_serialize(
+            ids=ids,
+            lang=lang,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "GeocodeResponseEnvelopePropertiesV2",
+            '400': "GeocodeResponseEnvelopePropertiesV2",
+            '500': "GeocodeResponseEnvelopePropertiesV2",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _place_details_v2_serialize(
+        self,
+        ids,
+        lang,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+            'ids': 'csv',
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        # process the query parameters
+        if ids is not None:
+            
+            _query_params.append(('ids', ids))
+            
+        if lang is not None:
+            
+            _query_params.append(('lang', lang))
+            
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'ApiKeyAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/geocoding/v2/place_details',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def reverse(
+        self,
+        point_lat: Annotated[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]], Field(description="The latitude of the point at which to perform the search.")],
+        point_lon: Annotated[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]], Field(description="The longitude of the point at which to perform the search.")],
+        boundary_circle_radius: Annotated[Optional[Union[StrictFloat, StrictInt]], Field(description="The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.")] = None,
+        layers: Annotated[Optional[List[GeocodingLayer]], Field(description="A list of layers to limit the search to.")] = None,
+        sources: Annotated[Optional[List[GeocodingSource]], Field(description="A list of sources to limit the search to.")] = None,
+        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.")] = None,
+        boundary_gid: Annotated[Optional[StrictStr], Field(description="The GID of an area to limit the search to.")] = None,
+        size: Annotated[Optional[StrictInt], Field(description="The maximum number of results to return.")] = None,
+        lang: Annotated[Optional[StrictStr], Field(description="A BCP47 language tag which specifies a preference for localization of results. By default, results are in the default locale of the source data, but specifying a language will attempt to localize the results. Note that while a `langtag` (in RFC 5646 terms) can contain script, region, etc., only the `language` portion, an ISO 639 code, will be considered. So `en-US` and `en-GB` will both be treated as English.")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> GeocodeResponse:
-        """Retrieve details of a place using its GID.
+        """Find places and addresses near geographic coordinates (reverse geocoding).
 
-        Many search result components include an associated GID field (for example, an address may have a `localadmin_gid`). The place endpoint lets you look up these places directly by ID. Note that GIDs are not stable for all sources. See the [online documentation](https://docs.stadiamaps.com/geocoding-search-autocomplete/place-lookup/) for details.
+        Reverse geocoding and search finds places and addresses near any geographic coordinates.
 
-        :param ids: A list of GIDs to search for. (required)
-        :type ids: List[str]
+        :param point_lat: The latitude of the point at which to perform the search. (required)
+        :type point_lat: float
+        :param point_lon: The longitude of the point at which to perform the search. (required)
+        :type point_lon: float
+        :param boundary_circle_radius: The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.
+        :type boundary_circle_radius: float
+        :param layers: A list of layers to limit the search to.
+        :type layers: List[GeocodingLayer]
+        :param sources: A list of sources to limit the search to.
+        :type sources: List[GeocodingSource]
+        :param boundary_country: A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.
+        :type boundary_country: List[str]
+        :param boundary_gid: The GID of an area to limit the search to.
+        :type boundary_gid: str
+        :param size: The maximum number of results to return.
+        :type size: int
         :param lang: A BCP47 language tag which specifies a preference for localization of results. By default, results are in the default locale of the source data, but specifying a language will attempt to localize the results. Note that while a `langtag` (in RFC 5646 terms) can contain script, region, etc., only the `language` portion, an ISO 639 code, will be considered. So `en-US` and `en-GB` will both be treated as English.
         :type lang: str
         :param _request_timeout: timeout setting for this request. If one
@@ -616,8 +1732,15 @@ class GeocodingApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._place_serialize(
-            ids=ids,
+        _param = self._reverse_serialize(
+            point_lat=point_lat,
+            point_lon=point_lon,
+            boundary_circle_radius=boundary_circle_radius,
+            layers=layers,
+            sources=sources,
+            boundary_country=boundary_country,
+            boundary_gid=boundary_gid,
+            size=size,
             lang=lang,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -641,9 +1764,16 @@ class GeocodingApi:
 
 
     @validate_call
-    def place_with_http_info(
+    def reverse_with_http_info(
         self,
-        ids: Annotated[List[StrictStr], Field(description="A list of GIDs to search for.")],
+        point_lat: Annotated[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]], Field(description="The latitude of the point at which to perform the search.")],
+        point_lon: Annotated[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]], Field(description="The longitude of the point at which to perform the search.")],
+        boundary_circle_radius: Annotated[Optional[Union[StrictFloat, StrictInt]], Field(description="The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.")] = None,
+        layers: Annotated[Optional[List[GeocodingLayer]], Field(description="A list of layers to limit the search to.")] = None,
+        sources: Annotated[Optional[List[GeocodingSource]], Field(description="A list of sources to limit the search to.")] = None,
+        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.")] = None,
+        boundary_gid: Annotated[Optional[StrictStr], Field(description="The GID of an area to limit the search to.")] = None,
+        size: Annotated[Optional[StrictInt], Field(description="The maximum number of results to return.")] = None,
         lang: Annotated[Optional[StrictStr], Field(description="A BCP47 language tag which specifies a preference for localization of results. By default, results are in the default locale of the source data, but specifying a language will attempt to localize the results. Note that while a `langtag` (in RFC 5646 terms) can contain script, region, etc., only the `language` portion, an ISO 639 code, will be considered. So `en-US` and `en-GB` will both be treated as English.")] = None,
         _request_timeout: Union[
             None,
@@ -658,12 +1788,26 @@ class GeocodingApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[GeocodeResponse]:
-        """Retrieve details of a place using its GID.
+        """Find places and addresses near geographic coordinates (reverse geocoding).
 
-        Many search result components include an associated GID field (for example, an address may have a `localadmin_gid`). The place endpoint lets you look up these places directly by ID. Note that GIDs are not stable for all sources. See the [online documentation](https://docs.stadiamaps.com/geocoding-search-autocomplete/place-lookup/) for details.
+        Reverse geocoding and search finds places and addresses near any geographic coordinates.
 
-        :param ids: A list of GIDs to search for. (required)
-        :type ids: List[str]
+        :param point_lat: The latitude of the point at which to perform the search. (required)
+        :type point_lat: float
+        :param point_lon: The longitude of the point at which to perform the search. (required)
+        :type point_lon: float
+        :param boundary_circle_radius: The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.
+        :type boundary_circle_radius: float
+        :param layers: A list of layers to limit the search to.
+        :type layers: List[GeocodingLayer]
+        :param sources: A list of sources to limit the search to.
+        :type sources: List[GeocodingSource]
+        :param boundary_country: A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.
+        :type boundary_country: List[str]
+        :param boundary_gid: The GID of an area to limit the search to.
+        :type boundary_gid: str
+        :param size: The maximum number of results to return.
+        :type size: int
         :param lang: A BCP47 language tag which specifies a preference for localization of results. By default, results are in the default locale of the source data, but specifying a language will attempt to localize the results. Note that while a `langtag` (in RFC 5646 terms) can contain script, region, etc., only the `language` portion, an ISO 639 code, will be considered. So `en-US` and `en-GB` will both be treated as English.
         :type lang: str
         :param _request_timeout: timeout setting for this request. If one
@@ -688,8 +1832,15 @@ class GeocodingApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._place_serialize(
-            ids=ids,
+        _param = self._reverse_serialize(
+            point_lat=point_lat,
+            point_lon=point_lon,
+            boundary_circle_radius=boundary_circle_radius,
+            layers=layers,
+            sources=sources,
+            boundary_country=boundary_country,
+            boundary_gid=boundary_gid,
+            size=size,
             lang=lang,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -713,9 +1864,16 @@ class GeocodingApi:
 
 
     @validate_call
-    def place_without_preload_content(
+    def reverse_without_preload_content(
         self,
-        ids: Annotated[List[StrictStr], Field(description="A list of GIDs to search for.")],
+        point_lat: Annotated[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]], Field(description="The latitude of the point at which to perform the search.")],
+        point_lon: Annotated[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]], Field(description="The longitude of the point at which to perform the search.")],
+        boundary_circle_radius: Annotated[Optional[Union[StrictFloat, StrictInt]], Field(description="The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.")] = None,
+        layers: Annotated[Optional[List[GeocodingLayer]], Field(description="A list of layers to limit the search to.")] = None,
+        sources: Annotated[Optional[List[GeocodingSource]], Field(description="A list of sources to limit the search to.")] = None,
+        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.")] = None,
+        boundary_gid: Annotated[Optional[StrictStr], Field(description="The GID of an area to limit the search to.")] = None,
+        size: Annotated[Optional[StrictInt], Field(description="The maximum number of results to return.")] = None,
         lang: Annotated[Optional[StrictStr], Field(description="A BCP47 language tag which specifies a preference for localization of results. By default, results are in the default locale of the source data, but specifying a language will attempt to localize the results. Note that while a `langtag` (in RFC 5646 terms) can contain script, region, etc., only the `language` portion, an ISO 639 code, will be considered. So `en-US` and `en-GB` will both be treated as English.")] = None,
         _request_timeout: Union[
             None,
@@ -730,12 +1888,26 @@ class GeocodingApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Retrieve details of a place using its GID.
+        """Find places and addresses near geographic coordinates (reverse geocoding).
 
-        Many search result components include an associated GID field (for example, an address may have a `localadmin_gid`). The place endpoint lets you look up these places directly by ID. Note that GIDs are not stable for all sources. See the [online documentation](https://docs.stadiamaps.com/geocoding-search-autocomplete/place-lookup/) for details.
+        Reverse geocoding and search finds places and addresses near any geographic coordinates.
 
-        :param ids: A list of GIDs to search for. (required)
-        :type ids: List[str]
+        :param point_lat: The latitude of the point at which to perform the search. (required)
+        :type point_lat: float
+        :param point_lon: The longitude of the point at which to perform the search. (required)
+        :type point_lon: float
+        :param boundary_circle_radius: The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.
+        :type boundary_circle_radius: float
+        :param layers: A list of layers to limit the search to.
+        :type layers: List[GeocodingLayer]
+        :param sources: A list of sources to limit the search to.
+        :type sources: List[GeocodingSource]
+        :param boundary_country: A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.
+        :type boundary_country: List[str]
+        :param boundary_gid: The GID of an area to limit the search to.
+        :type boundary_gid: str
+        :param size: The maximum number of results to return.
+        :type size: int
         :param lang: A BCP47 language tag which specifies a preference for localization of results. By default, results are in the default locale of the source data, but specifying a language will attempt to localize the results. Note that while a `langtag` (in RFC 5646 terms) can contain script, region, etc., only the `language` portion, an ISO 639 code, will be considered. So `en-US` and `en-GB` will both be treated as English.
         :type lang: str
         :param _request_timeout: timeout setting for this request. If one
@@ -760,8 +1932,15 @@ class GeocodingApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._place_serialize(
-            ids=ids,
+        _param = self._reverse_serialize(
+            point_lat=point_lat,
+            point_lon=point_lon,
+            boundary_circle_radius=boundary_circle_radius,
+            layers=layers,
+            sources=sources,
+            boundary_country=boundary_country,
+            boundary_gid=boundary_gid,
+            size=size,
             lang=lang,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -780,9 +1959,16 @@ class GeocodingApi:
         return response_data.response
 
 
-    def _place_serialize(
+    def _reverse_serialize(
         self,
-        ids,
+        point_lat,
+        point_lon,
+        boundary_circle_radius,
+        layers,
+        sources,
+        boundary_country,
+        boundary_gid,
+        size,
         lang,
         _request_auth,
         _content_type,
@@ -793,7 +1979,9 @@ class GeocodingApi:
         _host = None
 
         _collection_formats: Dict[str, str] = {
-            'ids': 'csv',
+            'layers': 'csv',
+            'sources': 'csv',
+            'boundary.country': 'csv',
         }
 
         _path_params: Dict[str, str] = {}
@@ -807,9 +1995,37 @@ class GeocodingApi:
 
         # process the path parameters
         # process the query parameters
-        if ids is not None:
+        if point_lat is not None:
             
-            _query_params.append(('ids', ids))
+            _query_params.append(('point.lat', point_lat))
+            
+        if point_lon is not None:
+            
+            _query_params.append(('point.lon', point_lon))
+            
+        if boundary_circle_radius is not None:
+            
+            _query_params.append(('boundary.circle.radius', boundary_circle_radius))
+            
+        if layers is not None:
+            
+            _query_params.append(('layers', layers))
+            
+        if sources is not None:
+            
+            _query_params.append(('sources', sources))
+            
+        if boundary_country is not None:
+            
+            _query_params.append(('boundary.country', boundary_country))
+            
+        if boundary_gid is not None:
+            
+            _query_params.append(('boundary.gid', boundary_gid))
+            
+        if size is not None:
+            
+            _query_params.append(('size', size))
             
         if lang is not None:
             
@@ -836,7 +2052,7 @@ class GeocodingApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/geocoding/v1/place',
+            resource_path='/geocoding/v1/reverse',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -853,17 +2069,19 @@ class GeocodingApi:
 
 
     @validate_call
-    def reverse(
+    def reverse_v2(
         self,
         point_lat: Annotated[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]], Field(description="The latitude of the point at which to perform the search.")],
         point_lon: Annotated[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]], Field(description="The longitude of the point at which to perform the search.")],
-        boundary_circle_radius: Annotated[Optional[Union[StrictFloat, StrictInt]], Field(description="The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.")] = None,
-        layers: Annotated[Optional[List[GeocodingLayer]], Field(description="A list of layers to limit the search to.")] = None,
-        sources: Annotated[Optional[List[GeocodingSource]], Field(description="A list of sources to limit the search to.")] = None,
-        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.")] = None,
-        boundary_gid: Annotated[Optional[StrictStr], Field(description="The GID of an area to limit the search to.")] = None,
-        size: Annotated[Optional[StrictInt], Field(description="The maximum number of results to return.")] = None,
-        lang: Annotated[Optional[StrictStr], Field(description="A BCP47 language tag which specifies a preference for localization of results. By default, results are in the default locale of the source data, but specifying a language will attempt to localize the results. Note that while a `langtag` (in RFC 5646 terms) can contain script, region, etc., only the `language` portion, an ISO 639 code, will be considered. So `en-US` and `en-GB` will both be treated as English.")] = None,
+        layers: Annotated[Optional[List[LayerId]], Field(description="A list of layers to limit the search to.")] = None,
+        sources: Annotated[Optional[List[SourceId]], Field(description="A list of sources to limit the search to.")] = None,
+        boundary_gid: Annotated[Optional[StrictStr], Field(description="The GID of a region to limit the search to.  Note: these are not stable for all datasets! For example, OSM features may be deleted and re-added with a new ID.")] = None,
+        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of comma-separated country codes in ISO 3116-1 alpha-2 or alpha-3 format. The search will be limited to these countries.")] = None,
+        boundary_circle_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The latitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lon.")] = None,
+        boundary_circle_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The longitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lat.")] = None,
+        boundary_circle_radius: Annotated[Optional[Annotated[int, Field(strict=True, ge=0)]], Field(description="The radius of the circle (in kilometers) to limit the search to.  NOTE: Requires the other boundary.circle parameters to take effect. Defaults to 2km if unspecified.")] = None,
+        size: Annotated[Optional[Annotated[int, Field(le=25, strict=True, ge=1)]], Field(description="The maximum number of items to return from a query.")] = None,
+        lang: Annotated[Optional[StrictStr], Field(description="A BCP47 language tag which specifies a preference for localization of results. There is no default value, so place names will be returned as-is, which is usually in the local language. NOTE: The Accept-Language header is also respected, and many user agents will set it automatically.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -876,28 +2094,31 @@ class GeocodingApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> GeocodeResponse:
-        """Find places and addresses near geographic coordinates (reverse geocoding).
+    ) -> GeocodeResponseEnvelopePropertiesV2:
+        """reverse_v2
 
-        Reverse geocoding and search finds places and addresses near any geographic coordinates.
 
         :param point_lat: The latitude of the point at which to perform the search. (required)
         :type point_lat: float
         :param point_lon: The longitude of the point at which to perform the search. (required)
         :type point_lon: float
-        :param boundary_circle_radius: The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.
-        :type boundary_circle_radius: float
         :param layers: A list of layers to limit the search to.
-        :type layers: List[GeocodingLayer]
+        :type layers: List[LayerId]
         :param sources: A list of sources to limit the search to.
-        :type sources: List[GeocodingSource]
-        :param boundary_country: A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.
-        :type boundary_country: List[str]
-        :param boundary_gid: The GID of an area to limit the search to.
+        :type sources: List[SourceId]
+        :param boundary_gid: The GID of a region to limit the search to.  Note: these are not stable for all datasets! For example, OSM features may be deleted and re-added with a new ID.
         :type boundary_gid: str
-        :param size: The maximum number of results to return.
+        :param boundary_country: A list of comma-separated country codes in ISO 3116-1 alpha-2 or alpha-3 format. The search will be limited to these countries.
+        :type boundary_country: List[str]
+        :param boundary_circle_lat: The latitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lon.
+        :type boundary_circle_lat: float
+        :param boundary_circle_lon: The longitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lat.
+        :type boundary_circle_lon: float
+        :param boundary_circle_radius: The radius of the circle (in kilometers) to limit the search to.  NOTE: Requires the other boundary.circle parameters to take effect. Defaults to 2km if unspecified.
+        :type boundary_circle_radius: int
+        :param size: The maximum number of items to return from a query.
         :type size: int
-        :param lang: A BCP47 language tag which specifies a preference for localization of results. By default, results are in the default locale of the source data, but specifying a language will attempt to localize the results. Note that while a `langtag` (in RFC 5646 terms) can contain script, region, etc., only the `language` portion, an ISO 639 code, will be considered. So `en-US` and `en-GB` will both be treated as English.
+        :param lang: A BCP47 language tag which specifies a preference for localization of results. There is no default value, so place names will be returned as-is, which is usually in the local language. NOTE: The Accept-Language header is also respected, and many user agents will set it automatically.
         :type lang: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -921,14 +2142,16 @@ class GeocodingApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._reverse_serialize(
+        _param = self._reverse_v2_serialize(
             point_lat=point_lat,
             point_lon=point_lon,
-            boundary_circle_radius=boundary_circle_radius,
             layers=layers,
             sources=sources,
-            boundary_country=boundary_country,
             boundary_gid=boundary_gid,
+            boundary_country=boundary_country,
+            boundary_circle_lat=boundary_circle_lat,
+            boundary_circle_lon=boundary_circle_lon,
+            boundary_circle_radius=boundary_circle_radius,
             size=size,
             lang=lang,
             _request_auth=_request_auth,
@@ -938,8 +2161,9 @@ class GeocodingApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GeocodeResponse",
-            '400': None,
+            '200': "GeocodeResponseEnvelopePropertiesV2",
+            '400': "GeocodeResponseEnvelopePropertiesV2",
+            '500': "GeocodeResponseEnvelopePropertiesV2",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -953,17 +2177,19 @@ class GeocodingApi:
 
 
     @validate_call
-    def reverse_with_http_info(
+    def reverse_v2_with_http_info(
         self,
         point_lat: Annotated[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]], Field(description="The latitude of the point at which to perform the search.")],
         point_lon: Annotated[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]], Field(description="The longitude of the point at which to perform the search.")],
-        boundary_circle_radius: Annotated[Optional[Union[StrictFloat, StrictInt]], Field(description="The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.")] = None,
-        layers: Annotated[Optional[List[GeocodingLayer]], Field(description="A list of layers to limit the search to.")] = None,
-        sources: Annotated[Optional[List[GeocodingSource]], Field(description="A list of sources to limit the search to.")] = None,
-        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.")] = None,
-        boundary_gid: Annotated[Optional[StrictStr], Field(description="The GID of an area to limit the search to.")] = None,
-        size: Annotated[Optional[StrictInt], Field(description="The maximum number of results to return.")] = None,
-        lang: Annotated[Optional[StrictStr], Field(description="A BCP47 language tag which specifies a preference for localization of results. By default, results are in the default locale of the source data, but specifying a language will attempt to localize the results. Note that while a `langtag` (in RFC 5646 terms) can contain script, region, etc., only the `language` portion, an ISO 639 code, will be considered. So `en-US` and `en-GB` will both be treated as English.")] = None,
+        layers: Annotated[Optional[List[LayerId]], Field(description="A list of layers to limit the search to.")] = None,
+        sources: Annotated[Optional[List[SourceId]], Field(description="A list of sources to limit the search to.")] = None,
+        boundary_gid: Annotated[Optional[StrictStr], Field(description="The GID of a region to limit the search to.  Note: these are not stable for all datasets! For example, OSM features may be deleted and re-added with a new ID.")] = None,
+        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of comma-separated country codes in ISO 3116-1 alpha-2 or alpha-3 format. The search will be limited to these countries.")] = None,
+        boundary_circle_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The latitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lon.")] = None,
+        boundary_circle_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The longitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lat.")] = None,
+        boundary_circle_radius: Annotated[Optional[Annotated[int, Field(strict=True, ge=0)]], Field(description="The radius of the circle (in kilometers) to limit the search to.  NOTE: Requires the other boundary.circle parameters to take effect. Defaults to 2km if unspecified.")] = None,
+        size: Annotated[Optional[Annotated[int, Field(le=25, strict=True, ge=1)]], Field(description="The maximum number of items to return from a query.")] = None,
+        lang: Annotated[Optional[StrictStr], Field(description="A BCP47 language tag which specifies a preference for localization of results. There is no default value, so place names will be returned as-is, which is usually in the local language. NOTE: The Accept-Language header is also respected, and many user agents will set it automatically.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -976,28 +2202,31 @@ class GeocodingApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[GeocodeResponse]:
-        """Find places and addresses near geographic coordinates (reverse geocoding).
+    ) -> ApiResponse[GeocodeResponseEnvelopePropertiesV2]:
+        """reverse_v2
 
-        Reverse geocoding and search finds places and addresses near any geographic coordinates.
 
         :param point_lat: The latitude of the point at which to perform the search. (required)
         :type point_lat: float
         :param point_lon: The longitude of the point at which to perform the search. (required)
         :type point_lon: float
-        :param boundary_circle_radius: The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.
-        :type boundary_circle_radius: float
         :param layers: A list of layers to limit the search to.
-        :type layers: List[GeocodingLayer]
+        :type layers: List[LayerId]
         :param sources: A list of sources to limit the search to.
-        :type sources: List[GeocodingSource]
-        :param boundary_country: A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.
-        :type boundary_country: List[str]
-        :param boundary_gid: The GID of an area to limit the search to.
+        :type sources: List[SourceId]
+        :param boundary_gid: The GID of a region to limit the search to.  Note: these are not stable for all datasets! For example, OSM features may be deleted and re-added with a new ID.
         :type boundary_gid: str
-        :param size: The maximum number of results to return.
+        :param boundary_country: A list of comma-separated country codes in ISO 3116-1 alpha-2 or alpha-3 format. The search will be limited to these countries.
+        :type boundary_country: List[str]
+        :param boundary_circle_lat: The latitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lon.
+        :type boundary_circle_lat: float
+        :param boundary_circle_lon: The longitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lat.
+        :type boundary_circle_lon: float
+        :param boundary_circle_radius: The radius of the circle (in kilometers) to limit the search to.  NOTE: Requires the other boundary.circle parameters to take effect. Defaults to 2km if unspecified.
+        :type boundary_circle_radius: int
+        :param size: The maximum number of items to return from a query.
         :type size: int
-        :param lang: A BCP47 language tag which specifies a preference for localization of results. By default, results are in the default locale of the source data, but specifying a language will attempt to localize the results. Note that while a `langtag` (in RFC 5646 terms) can contain script, region, etc., only the `language` portion, an ISO 639 code, will be considered. So `en-US` and `en-GB` will both be treated as English.
+        :param lang: A BCP47 language tag which specifies a preference for localization of results. There is no default value, so place names will be returned as-is, which is usually in the local language. NOTE: The Accept-Language header is also respected, and many user agents will set it automatically.
         :type lang: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -1021,14 +2250,16 @@ class GeocodingApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._reverse_serialize(
+        _param = self._reverse_v2_serialize(
             point_lat=point_lat,
             point_lon=point_lon,
-            boundary_circle_radius=boundary_circle_radius,
             layers=layers,
             sources=sources,
-            boundary_country=boundary_country,
             boundary_gid=boundary_gid,
+            boundary_country=boundary_country,
+            boundary_circle_lat=boundary_circle_lat,
+            boundary_circle_lon=boundary_circle_lon,
+            boundary_circle_radius=boundary_circle_radius,
             size=size,
             lang=lang,
             _request_auth=_request_auth,
@@ -1038,8 +2269,9 @@ class GeocodingApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GeocodeResponse",
-            '400': None,
+            '200': "GeocodeResponseEnvelopePropertiesV2",
+            '400': "GeocodeResponseEnvelopePropertiesV2",
+            '500': "GeocodeResponseEnvelopePropertiesV2",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1053,17 +2285,19 @@ class GeocodingApi:
 
 
     @validate_call
-    def reverse_without_preload_content(
+    def reverse_v2_without_preload_content(
         self,
         point_lat: Annotated[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]], Field(description="The latitude of the point at which to perform the search.")],
         point_lon: Annotated[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]], Field(description="The longitude of the point at which to perform the search.")],
-        boundary_circle_radius: Annotated[Optional[Union[StrictFloat, StrictInt]], Field(description="The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.")] = None,
-        layers: Annotated[Optional[List[GeocodingLayer]], Field(description="A list of layers to limit the search to.")] = None,
-        sources: Annotated[Optional[List[GeocodingSource]], Field(description="A list of sources to limit the search to.")] = None,
-        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.")] = None,
-        boundary_gid: Annotated[Optional[StrictStr], Field(description="The GID of an area to limit the search to.")] = None,
-        size: Annotated[Optional[StrictInt], Field(description="The maximum number of results to return.")] = None,
-        lang: Annotated[Optional[StrictStr], Field(description="A BCP47 language tag which specifies a preference for localization of results. By default, results are in the default locale of the source data, but specifying a language will attempt to localize the results. Note that while a `langtag` (in RFC 5646 terms) can contain script, region, etc., only the `language` portion, an ISO 639 code, will be considered. So `en-US` and `en-GB` will both be treated as English.")] = None,
+        layers: Annotated[Optional[List[LayerId]], Field(description="A list of layers to limit the search to.")] = None,
+        sources: Annotated[Optional[List[SourceId]], Field(description="A list of sources to limit the search to.")] = None,
+        boundary_gid: Annotated[Optional[StrictStr], Field(description="The GID of a region to limit the search to.  Note: these are not stable for all datasets! For example, OSM features may be deleted and re-added with a new ID.")] = None,
+        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of comma-separated country codes in ISO 3116-1 alpha-2 or alpha-3 format. The search will be limited to these countries.")] = None,
+        boundary_circle_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The latitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lon.")] = None,
+        boundary_circle_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The longitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lat.")] = None,
+        boundary_circle_radius: Annotated[Optional[Annotated[int, Field(strict=True, ge=0)]], Field(description="The radius of the circle (in kilometers) to limit the search to.  NOTE: Requires the other boundary.circle parameters to take effect. Defaults to 2km if unspecified.")] = None,
+        size: Annotated[Optional[Annotated[int, Field(le=25, strict=True, ge=1)]], Field(description="The maximum number of items to return from a query.")] = None,
+        lang: Annotated[Optional[StrictStr], Field(description="A BCP47 language tag which specifies a preference for localization of results. There is no default value, so place names will be returned as-is, which is usually in the local language. NOTE: The Accept-Language header is also respected, and many user agents will set it automatically.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1077,27 +2311,30 @@ class GeocodingApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Find places and addresses near geographic coordinates (reverse geocoding).
+        """reverse_v2
 
-        Reverse geocoding and search finds places and addresses near any geographic coordinates.
 
         :param point_lat: The latitude of the point at which to perform the search. (required)
         :type point_lat: float
         :param point_lon: The longitude of the point at which to perform the search. (required)
         :type point_lon: float
-        :param boundary_circle_radius: The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.
-        :type boundary_circle_radius: float
         :param layers: A list of layers to limit the search to.
-        :type layers: List[GeocodingLayer]
+        :type layers: List[LayerId]
         :param sources: A list of sources to limit the search to.
-        :type sources: List[GeocodingSource]
-        :param boundary_country: A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.
-        :type boundary_country: List[str]
-        :param boundary_gid: The GID of an area to limit the search to.
+        :type sources: List[SourceId]
+        :param boundary_gid: The GID of a region to limit the search to.  Note: these are not stable for all datasets! For example, OSM features may be deleted and re-added with a new ID.
         :type boundary_gid: str
-        :param size: The maximum number of results to return.
+        :param boundary_country: A list of comma-separated country codes in ISO 3116-1 alpha-2 or alpha-3 format. The search will be limited to these countries.
+        :type boundary_country: List[str]
+        :param boundary_circle_lat: The latitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lon.
+        :type boundary_circle_lat: float
+        :param boundary_circle_lon: The longitude of the center of a circle to limit the search to.  NOTE: Requires boundary.circle.lat.
+        :type boundary_circle_lon: float
+        :param boundary_circle_radius: The radius of the circle (in kilometers) to limit the search to.  NOTE: Requires the other boundary.circle parameters to take effect. Defaults to 2km if unspecified.
+        :type boundary_circle_radius: int
+        :param size: The maximum number of items to return from a query.
         :type size: int
-        :param lang: A BCP47 language tag which specifies a preference for localization of results. By default, results are in the default locale of the source data, but specifying a language will attempt to localize the results. Note that while a `langtag` (in RFC 5646 terms) can contain script, region, etc., only the `language` portion, an ISO 639 code, will be considered. So `en-US` and `en-GB` will both be treated as English.
+        :param lang: A BCP47 language tag which specifies a preference for localization of results. There is no default value, so place names will be returned as-is, which is usually in the local language. NOTE: The Accept-Language header is also respected, and many user agents will set it automatically.
         :type lang: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -1121,14 +2358,16 @@ class GeocodingApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._reverse_serialize(
+        _param = self._reverse_v2_serialize(
             point_lat=point_lat,
             point_lon=point_lon,
-            boundary_circle_radius=boundary_circle_radius,
             layers=layers,
             sources=sources,
-            boundary_country=boundary_country,
             boundary_gid=boundary_gid,
+            boundary_country=boundary_country,
+            boundary_circle_lat=boundary_circle_lat,
+            boundary_circle_lon=boundary_circle_lon,
+            boundary_circle_radius=boundary_circle_radius,
             size=size,
             lang=lang,
             _request_auth=_request_auth,
@@ -1138,8 +2377,9 @@ class GeocodingApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GeocodeResponse",
-            '400': None,
+            '200': "GeocodeResponseEnvelopePropertiesV2",
+            '400': "GeocodeResponseEnvelopePropertiesV2",
+            '500': "GeocodeResponseEnvelopePropertiesV2",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1148,15 +2388,17 @@ class GeocodingApi:
         return response_data.response
 
 
-    def _reverse_serialize(
+    def _reverse_v2_serialize(
         self,
         point_lat,
         point_lon,
-        boundary_circle_radius,
         layers,
         sources,
-        boundary_country,
         boundary_gid,
+        boundary_country,
+        boundary_circle_lat,
+        boundary_circle_lon,
+        boundary_circle_radius,
         size,
         lang,
         _request_auth,
@@ -1192,10 +2434,6 @@ class GeocodingApi:
             
             _query_params.append(('point.lon', point_lon))
             
-        if boundary_circle_radius is not None:
-            
-            _query_params.append(('boundary.circle.radius', boundary_circle_radius))
-            
         if layers is not None:
             
             _query_params.append(('layers', layers))
@@ -1204,13 +2442,25 @@ class GeocodingApi:
             
             _query_params.append(('sources', sources))
             
+        if boundary_gid is not None:
+            
+            _query_params.append(('boundary.gid', boundary_gid))
+            
         if boundary_country is not None:
             
             _query_params.append(('boundary.country', boundary_country))
             
-        if boundary_gid is not None:
+        if boundary_circle_lat is not None:
             
-            _query_params.append(('boundary.gid', boundary_gid))
+            _query_params.append(('boundary.circle.lat', boundary_circle_lat))
+            
+        if boundary_circle_lon is not None:
+            
+            _query_params.append(('boundary.circle.lon', boundary_circle_lon))
+            
+        if boundary_circle_radius is not None:
+            
+            _query_params.append(('boundary.circle.radius', boundary_circle_radius))
             
         if size is not None:
             
@@ -1241,7 +2491,7 @@ class GeocodingApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/geocoding/v1/reverse',
+            resource_path='/geocoding/v2/reverse',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1270,7 +2520,7 @@ class GeocodingApi:
         boundary_circle_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The latitude of the center of a circle to limit the search to. Requires `boundary.circle.lon`.")] = None,
         boundary_circle_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The longitude of the center of a circle to limit the search to. Requires `boundary.circle.lat`.")] = None,
         boundary_circle_radius: Annotated[Optional[Union[StrictFloat, StrictInt]], Field(description="The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.")] = None,
-        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.")] = None,
+        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.")] = None,
         boundary_gid: Annotated[Optional[StrictStr], Field(description="The GID of an area to limit the search to.")] = None,
         layers: Annotated[Optional[List[GeocodingLayer]], Field(description="A list of layers to limit the search to.")] = None,
         sources: Annotated[Optional[List[GeocodingSource]], Field(description="A list of sources to limit the search to.")] = None,
@@ -1313,7 +2563,7 @@ class GeocodingApi:
         :type boundary_circle_lon: float
         :param boundary_circle_radius: The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.
         :type boundary_circle_radius: float
-        :param boundary_country: A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.
+        :param boundary_country: A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.
         :type boundary_country: List[str]
         :param boundary_gid: The GID of an area to limit the search to.
         :type boundary_gid: str
@@ -1398,7 +2648,7 @@ class GeocodingApi:
         boundary_circle_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The latitude of the center of a circle to limit the search to. Requires `boundary.circle.lon`.")] = None,
         boundary_circle_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The longitude of the center of a circle to limit the search to. Requires `boundary.circle.lat`.")] = None,
         boundary_circle_radius: Annotated[Optional[Union[StrictFloat, StrictInt]], Field(description="The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.")] = None,
-        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.")] = None,
+        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.")] = None,
         boundary_gid: Annotated[Optional[StrictStr], Field(description="The GID of an area to limit the search to.")] = None,
         layers: Annotated[Optional[List[GeocodingLayer]], Field(description="A list of layers to limit the search to.")] = None,
         sources: Annotated[Optional[List[GeocodingSource]], Field(description="A list of sources to limit the search to.")] = None,
@@ -1441,7 +2691,7 @@ class GeocodingApi:
         :type boundary_circle_lon: float
         :param boundary_circle_radius: The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.
         :type boundary_circle_radius: float
-        :param boundary_country: A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.
+        :param boundary_country: A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.
         :type boundary_country: List[str]
         :param boundary_gid: The GID of an area to limit the search to.
         :type boundary_gid: str
@@ -1526,7 +2776,7 @@ class GeocodingApi:
         boundary_circle_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The latitude of the center of a circle to limit the search to. Requires `boundary.circle.lon`.")] = None,
         boundary_circle_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The longitude of the center of a circle to limit the search to. Requires `boundary.circle.lat`.")] = None,
         boundary_circle_radius: Annotated[Optional[Union[StrictFloat, StrictInt]], Field(description="The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.")] = None,
-        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.")] = None,
+        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.")] = None,
         boundary_gid: Annotated[Optional[StrictStr], Field(description="The GID of an area to limit the search to.")] = None,
         layers: Annotated[Optional[List[GeocodingLayer]], Field(description="A list of layers to limit the search to.")] = None,
         sources: Annotated[Optional[List[GeocodingSource]], Field(description="A list of sources to limit the search to.")] = None,
@@ -1569,7 +2819,7 @@ class GeocodingApi:
         :type boundary_circle_lon: float
         :param boundary_circle_radius: The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.
         :type boundary_circle_radius: float
-        :param boundary_country: A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.
+        :param boundary_country: A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.
         :type boundary_country: List[str]
         :param boundary_gid: The GID of an area to limit the search to.
         :type boundary_gid: str
@@ -2069,7 +3319,7 @@ class GeocodingApi:
         county: Annotated[Optional[StrictStr], Field(description="Administrative divisions between localities and regions. Not commonly used as input to structured geocoding.")] = None,
         region: Annotated[Optional[StrictStr], Field(description="Typically the first administrative division within a country. For example, a US state or a Canadian province.")] = None,
         postalcode: Annotated[Optional[StrictStr], Field(description="A mail sorting code.")] = None,
-        country: Annotated[Optional[StrictStr], Field(description="A full name (ex: Canada), or a 2 or 3 character ISO code. Prefer ISO codes when possible.")] = None,
+        country: Annotated[Optional[StrictStr], Field(description="A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.")] = None,
         focus_point_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The latitude of the point to focus the search on. This will bias results toward the focus point. Requires `focus.point.lon`.")] = None,
         focus_point_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The longitude of the point to focus the search on. This will bias results toward the focus point. Requires `focus.point.lat`.")] = None,
         boundary_rect_min_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="Defines the min latitude component of a bounding box to limit the search to. Requires all other `boundary.rect` parameters to be specified.")] = None,
@@ -2079,7 +3329,7 @@ class GeocodingApi:
         boundary_circle_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The latitude of the center of a circle to limit the search to. Requires `boundary.circle.lon`.")] = None,
         boundary_circle_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The longitude of the center of a circle to limit the search to. Requires `boundary.circle.lat`.")] = None,
         boundary_circle_radius: Annotated[Optional[Union[StrictFloat, StrictInt]], Field(description="The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.")] = None,
-        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.")] = None,
+        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.")] = None,
         boundary_gid: Annotated[Optional[StrictStr], Field(description="The GID of an area to limit the search to.")] = None,
         layers: Annotated[Optional[List[GeocodingLayer]], Field(description="A list of layers to limit the search to.")] = None,
         sources: Annotated[Optional[List[GeocodingSource]], Field(description="A list of sources to limit the search to.")] = None,
@@ -2116,7 +3366,7 @@ class GeocodingApi:
         :type region: str
         :param postalcode: A mail sorting code.
         :type postalcode: str
-        :param country: A full name (ex: Canada), or a 2 or 3 character ISO code. Prefer ISO codes when possible.
+        :param country: A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.
         :type country: str
         :param focus_point_lat: The latitude of the point to focus the search on. This will bias results toward the focus point. Requires `focus.point.lon`.
         :type focus_point_lat: float
@@ -2136,7 +3386,7 @@ class GeocodingApi:
         :type boundary_circle_lon: float
         :param boundary_circle_radius: The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.
         :type boundary_circle_radius: float
-        :param boundary_country: A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.
+        :param boundary_country: A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.
         :type boundary_country: List[str]
         :param boundary_gid: The GID of an area to limit the search to.
         :type boundary_gid: str
@@ -2225,7 +3475,7 @@ class GeocodingApi:
         county: Annotated[Optional[StrictStr], Field(description="Administrative divisions between localities and regions. Not commonly used as input to structured geocoding.")] = None,
         region: Annotated[Optional[StrictStr], Field(description="Typically the first administrative division within a country. For example, a US state or a Canadian province.")] = None,
         postalcode: Annotated[Optional[StrictStr], Field(description="A mail sorting code.")] = None,
-        country: Annotated[Optional[StrictStr], Field(description="A full name (ex: Canada), or a 2 or 3 character ISO code. Prefer ISO codes when possible.")] = None,
+        country: Annotated[Optional[StrictStr], Field(description="A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.")] = None,
         focus_point_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The latitude of the point to focus the search on. This will bias results toward the focus point. Requires `focus.point.lon`.")] = None,
         focus_point_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The longitude of the point to focus the search on. This will bias results toward the focus point. Requires `focus.point.lat`.")] = None,
         boundary_rect_min_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="Defines the min latitude component of a bounding box to limit the search to. Requires all other `boundary.rect` parameters to be specified.")] = None,
@@ -2235,7 +3485,7 @@ class GeocodingApi:
         boundary_circle_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The latitude of the center of a circle to limit the search to. Requires `boundary.circle.lon`.")] = None,
         boundary_circle_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The longitude of the center of a circle to limit the search to. Requires `boundary.circle.lat`.")] = None,
         boundary_circle_radius: Annotated[Optional[Union[StrictFloat, StrictInt]], Field(description="The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.")] = None,
-        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.")] = None,
+        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.")] = None,
         boundary_gid: Annotated[Optional[StrictStr], Field(description="The GID of an area to limit the search to.")] = None,
         layers: Annotated[Optional[List[GeocodingLayer]], Field(description="A list of layers to limit the search to.")] = None,
         sources: Annotated[Optional[List[GeocodingSource]], Field(description="A list of sources to limit the search to.")] = None,
@@ -2272,7 +3522,7 @@ class GeocodingApi:
         :type region: str
         :param postalcode: A mail sorting code.
         :type postalcode: str
-        :param country: A full name (ex: Canada), or a 2 or 3 character ISO code. Prefer ISO codes when possible.
+        :param country: A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.
         :type country: str
         :param focus_point_lat: The latitude of the point to focus the search on. This will bias results toward the focus point. Requires `focus.point.lon`.
         :type focus_point_lat: float
@@ -2292,7 +3542,7 @@ class GeocodingApi:
         :type boundary_circle_lon: float
         :param boundary_circle_radius: The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.
         :type boundary_circle_radius: float
-        :param boundary_country: A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.
+        :param boundary_country: A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.
         :type boundary_country: List[str]
         :param boundary_gid: The GID of an area to limit the search to.
         :type boundary_gid: str
@@ -2381,7 +3631,7 @@ class GeocodingApi:
         county: Annotated[Optional[StrictStr], Field(description="Administrative divisions between localities and regions. Not commonly used as input to structured geocoding.")] = None,
         region: Annotated[Optional[StrictStr], Field(description="Typically the first administrative division within a country. For example, a US state or a Canadian province.")] = None,
         postalcode: Annotated[Optional[StrictStr], Field(description="A mail sorting code.")] = None,
-        country: Annotated[Optional[StrictStr], Field(description="A full name (ex: Canada), or a 2 or 3 character ISO code. Prefer ISO codes when possible.")] = None,
+        country: Annotated[Optional[StrictStr], Field(description="A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.")] = None,
         focus_point_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The latitude of the point to focus the search on. This will bias results toward the focus point. Requires `focus.point.lon`.")] = None,
         focus_point_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The longitude of the point to focus the search on. This will bias results toward the focus point. Requires `focus.point.lat`.")] = None,
         boundary_rect_min_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="Defines the min latitude component of a bounding box to limit the search to. Requires all other `boundary.rect` parameters to be specified.")] = None,
@@ -2391,7 +3641,7 @@ class GeocodingApi:
         boundary_circle_lat: Annotated[Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]], Field(description="The latitude of the center of a circle to limit the search to. Requires `boundary.circle.lon`.")] = None,
         boundary_circle_lon: Annotated[Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]], Field(description="The longitude of the center of a circle to limit the search to. Requires `boundary.circle.lat`.")] = None,
         boundary_circle_radius: Annotated[Optional[Union[StrictFloat, StrictInt]], Field(description="The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.")] = None,
-        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.")] = None,
+        boundary_country: Annotated[Optional[List[StrictStr]], Field(description="A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.")] = None,
         boundary_gid: Annotated[Optional[StrictStr], Field(description="The GID of an area to limit the search to.")] = None,
         layers: Annotated[Optional[List[GeocodingLayer]], Field(description="A list of layers to limit the search to.")] = None,
         sources: Annotated[Optional[List[GeocodingSource]], Field(description="A list of sources to limit the search to.")] = None,
@@ -2428,7 +3678,7 @@ class GeocodingApi:
         :type region: str
         :param postalcode: A mail sorting code.
         :type postalcode: str
-        :param country: A full name (ex: Canada), or a 2 or 3 character ISO code. Prefer ISO codes when possible.
+        :param country: A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.
         :type country: str
         :param focus_point_lat: The latitude of the point to focus the search on. This will bias results toward the focus point. Requires `focus.point.lon`.
         :type focus_point_lat: float
@@ -2448,7 +3698,7 @@ class GeocodingApi:
         :type boundary_circle_lon: float
         :param boundary_circle_radius: The radius of the circle (in kilometers) to limit the search to. Defaults to 50km if unspecified.
         :type boundary_circle_radius: float
-        :param boundary_country: A list of countries to limit the search to. These may be either full names (ex: Canada), or an ISO 3116-1 alpha-2 or alpha-3 code. Prefer ISO codes when possible.
+        :param boundary_country: A list of country codes in ISO 3116-1 alpha-2 or alpha-3 format.
         :type boundary_country: List[str]
         :param boundary_gid: The GID of an area to limit the search to.
         :type boundary_gid: str