stadiamaps 5.0.0__py3-none-any.whl → 6.0.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.0.0
     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,531 @@ 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,
@@ -616,7 +1143,7 @@ class GeocodingApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._place_serialize(
+        _param = self._place_details_serialize(
             ids=ids,
             lang=lang,
             _request_auth=_request_auth,
@@ -641,7 +1168,7 @@ class GeocodingApi:
 
 
     @validate_call
-    def place_with_http_info(
+    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,
@@ -688,7 +1215,7 @@ class GeocodingApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._place_serialize(
+        _param = self._place_details_serialize(
             ids=ids,
             lang=lang,
             _request_auth=_request_auth,
@@ -713,7 +1240,7 @@ class GeocodingApi:
 
 
     @validate_call
-    def place_without_preload_content(
+    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,
@@ -760,7 +1287,7 @@ class GeocodingApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._place_serialize(
+        _param = self._place_details_serialize(
             ids=ids,
             lang=lang,
             _request_auth=_request_auth,
@@ -780,7 +1307,7 @@ class GeocodingApi:
         return response_data.response
 
 
-    def _place_serialize(
+    def _place_details_serialize(
         self,
         ids,
         lang,
@@ -852,6 +1379,290 @@ class GeocodingApi:
 
 
 
+    @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,
@@ -860,7 +1671,7 @@ class GeocodingApi:
         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_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,
@@ -891,7 +1702,7 @@ class GeocodingApi:
         :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 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
@@ -960,7 +1771,7 @@ class GeocodingApi:
         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_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,
@@ -991,7 +1802,7 @@ class GeocodingApi:
         :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 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
@@ -1060,7 +1871,7 @@ class GeocodingApi:
         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_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,
@@ -1091,7 +1902,7 @@ class GeocodingApi:
         :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 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
@@ -1270,7 +2081,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 +2124,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 +2209,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 +2252,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 +2337,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 +2380,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 +2880,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 +2890,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 +2927,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 +2947,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 +3036,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 +3046,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 +3083,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 +3103,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 +3192,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 +3202,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 +3239,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 +3259,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