stadiamaps 4.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: 7.0.0
+    The version of the OpenAPI document: 9.0.0
     Contact: support@stadiamaps.com
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
@@ -22,9 +22,12 @@ from typing import List, Optional, Union
 from typing_extensions import Annotated
 from stadiamaps.models.bulk_request import BulkRequest
 from stadiamaps.models.bulk_search_response import BulkSearchResponse
-from stadiamaps.models.pelias_layer import PeliasLayer
-from stadiamaps.models.pelias_response import PeliasResponse
-from stadiamaps.models.pelias_source import PeliasSource
+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,10 +60,10 @@ 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_gid: Annotated[Optional[StrictStr], Field(description="The Pelias GID of an area to limit the search to.")] = None,
-        layers: Annotated[Optional[List[PeliasLayer]], Field(description="A list of layers to limit the search to.")] = None,
-        sources: Annotated[Optional[List[PeliasSource]], 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,
+        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,
         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[
@@ -75,7 +78,7 @@ class GeocodingApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> PeliasResponse:
+    ) -> GeocodeResponse:
         """Search and geocode quickly based on partial input.
 
         Autocomplete enables interactive search-as-you-type user experiences, suggesting places as you type, along with information that will help your users find the correct place quickly.
@@ -100,14 +103,14 @@ 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 Pelias GID of an area to limit the search to.
+        :param boundary_gid: The GID of an area to limit the search to.
         :type boundary_gid: str
         :param layers: A list of layers to limit the search to.
-        :type layers: List[PeliasLayer]
+        :type layers: List[GeocodingLayer]
         :param sources: A list of sources to limit the search to.
-        :type sources: List[PeliasSource]
+        :type sources: List[GeocodingSource]
         :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.
@@ -158,7 +161,7 @@ class GeocodingApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PeliasResponse",
+            '200': "GeocodeResponse",
             '400': None,
         }
         response_data = self.api_client.call_api(
@@ -185,10 +188,10 @@ 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_gid: Annotated[Optional[StrictStr], Field(description="The Pelias GID of an area to limit the search to.")] = None,
-        layers: Annotated[Optional[List[PeliasLayer]], Field(description="A list of layers to limit the search to.")] = None,
-        sources: Annotated[Optional[List[PeliasSource]], 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,
+        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,
         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[
@@ -203,7 +206,7 @@ class GeocodingApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[PeliasResponse]:
+    ) -> ApiResponse[GeocodeResponse]:
         """Search and geocode quickly based on partial input.
 
         Autocomplete enables interactive search-as-you-type user experiences, suggesting places as you type, along with information that will help your users find the correct place quickly.
@@ -228,14 +231,14 @@ 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 Pelias GID of an area to limit the search to.
+        :param boundary_gid: The GID of an area to limit the search to.
         :type boundary_gid: str
         :param layers: A list of layers to limit the search to.
-        :type layers: List[PeliasLayer]
+        :type layers: List[GeocodingLayer]
         :param sources: A list of sources to limit the search to.
-        :type sources: List[PeliasSource]
+        :type sources: List[GeocodingSource]
         :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.
@@ -286,7 +289,7 @@ class GeocodingApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PeliasResponse",
+            '200': "GeocodeResponse",
             '400': None,
         }
         response_data = self.api_client.call_api(
@@ -313,10 +316,10 @@ 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_gid: Annotated[Optional[StrictStr], Field(description="The Pelias GID of an area to limit the search to.")] = None,
-        layers: Annotated[Optional[List[PeliasLayer]], Field(description="A list of layers to limit the search to.")] = None,
-        sources: Annotated[Optional[List[PeliasSource]], 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,
+        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,
         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[
@@ -356,14 +359,14 @@ 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 Pelias GID of an area to limit the search to.
+        :param boundary_gid: The GID of an area to limit the search to.
         :type boundary_gid: str
         :param layers: A list of layers to limit the search to.
-        :type layers: List[PeliasLayer]
+        :type layers: List[GeocodingLayer]
         :param sources: A list of sources to limit the search to.
-        :type sources: List[PeliasSource]
+        :type sources: List[GeocodingSource]
         :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.
@@ -414,7 +417,7 @@ class GeocodingApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PeliasResponse",
+            '200': "GeocodeResponse",
             '400': None,
         }
         response_data = self.api_client.call_api(
@@ -460,7 +463,9 @@ class GeocodingApi:
         _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]] = {}
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
         _body_params: Optional[bytes] = None
 
         # process the path parameters
@@ -567,9 +572,533 @@ class GeocodingApi:
 
 
     @validate_call
-    def place(
+    def autocomplete_v2(
         self,
-        ids: Annotated[List[StrictStr], Field(description="A list of Pelias GIDs to search for.")],
+        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,
@@ -583,12 +1112,12 @@ class GeocodingApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> PeliasResponse:
+    ) -> 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 these IDs are not stable for all sources. See the [online documentation](https://docs.stadiamaps.com/geocoding-search-autocomplete/place-lookup/) for details.
+        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 Pelias GIDs to search for. (required)
+        :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
@@ -614,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,
@@ -624,7 +1153,7 @@ class GeocodingApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PeliasResponse",
+            '200': "GeocodeResponse",
             '400': None,
         }
         response_data = self.api_client.call_api(
@@ -639,9 +1168,9 @@ 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 Pelias GIDs to search for.")],
+        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,
@@ -655,12 +1184,12 @@ class GeocodingApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[PeliasResponse]:
+    ) -> 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 these IDs are not stable for all sources. See the [online documentation](https://docs.stadiamaps.com/geocoding-search-autocomplete/place-lookup/) for details.
+        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 Pelias GIDs to search for. (required)
+        :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
@@ -686,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,
@@ -696,7 +1225,7 @@ class GeocodingApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PeliasResponse",
+            '200': "GeocodeResponse",
             '400': None,
         }
         response_data = self.api_client.call_api(
@@ -711,9 +1240,9 @@ 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 Pelias GIDs to search for.")],
+        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,
@@ -730,9 +1259,9 @@ class GeocodingApi:
     ) -> 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 these IDs are not stable for all sources. See the [online documentation](https://docs.stadiamaps.com/geocoding-search-autocomplete/place-lookup/) for details.
+        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 Pelias GIDs to search for. (required)
+        :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
@@ -758,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,
@@ -768,7 +1297,7 @@ class GeocodingApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PeliasResponse",
+            '200': "GeocodeResponse",
             '400': None,
         }
         response_data = self.api_client.call_api(
@@ -778,7 +1307,7 @@ class GeocodingApi:
         return response_data.response
 
 
-    def _place_serialize(
+    def _place_details_serialize(
         self,
         ids,
         lang,
@@ -798,7 +1327,9 @@ class GeocodingApi:
         _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]] = {}
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
         _body_params: Optional[bytes] = None
 
         # process the path parameters
@@ -848,16 +1379,300 @@ 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,
         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[PeliasLayer]], Field(description="A list of layers to limit the search to.")] = None,
-        sources: Annotated[Optional[List[PeliasSource]], 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 Pelias 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,
+        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[
@@ -872,7 +1687,7 @@ class GeocodingApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> PeliasResponse:
+    ) -> GeocodeResponse:
         """Find places and addresses near geographic coordinates (reverse geocoding).
 
         Reverse geocoding and search finds places and addresses near any geographic coordinates.
@@ -884,12 +1699,12 @@ class GeocodingApi:
         :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[PeliasLayer]
+        :type layers: List[GeocodingLayer]
         :param sources: A list of sources to limit the search to.
-        :type sources: List[PeliasSource]
-        :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 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 Pelias GID of an area to limit the search to.
+        :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
@@ -934,7 +1749,7 @@ class GeocodingApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PeliasResponse",
+            '200': "GeocodeResponse",
             '400': None,
         }
         response_data = self.api_client.call_api(
@@ -954,10 +1769,10 @@ class GeocodingApi:
         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[PeliasLayer]], Field(description="A list of layers to limit the search to.")] = None,
-        sources: Annotated[Optional[List[PeliasSource]], 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 Pelias 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,
+        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[
@@ -972,7 +1787,7 @@ class GeocodingApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[PeliasResponse]:
+    ) -> ApiResponse[GeocodeResponse]:
         """Find places and addresses near geographic coordinates (reverse geocoding).
 
         Reverse geocoding and search finds places and addresses near any geographic coordinates.
@@ -984,12 +1799,12 @@ class GeocodingApi:
         :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[PeliasLayer]
+        :type layers: List[GeocodingLayer]
         :param sources: A list of sources to limit the search to.
-        :type sources: List[PeliasSource]
-        :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 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 Pelias GID of an area to limit the search to.
+        :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
@@ -1034,7 +1849,7 @@ class GeocodingApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PeliasResponse",
+            '200': "GeocodeResponse",
             '400': None,
         }
         response_data = self.api_client.call_api(
@@ -1054,10 +1869,10 @@ class GeocodingApi:
         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[PeliasLayer]], Field(description="A list of layers to limit the search to.")] = None,
-        sources: Annotated[Optional[List[PeliasSource]], 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 Pelias 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,
+        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[
@@ -1084,12 +1899,12 @@ class GeocodingApi:
         :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[PeliasLayer]
+        :type layers: List[GeocodingLayer]
         :param sources: A list of sources to limit the search to.
-        :type sources: List[PeliasSource]
-        :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 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 Pelias GID of an area to limit the search to.
+        :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
@@ -1134,7 +1949,7 @@ class GeocodingApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PeliasResponse",
+            '200': "GeocodeResponse",
             '400': None,
         }
         response_data = self.api_client.call_api(
@@ -1173,7 +1988,9 @@ class GeocodingApi:
         _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]] = {}
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
         _body_params: Optional[bytes] = None
 
         # process the path parameters
@@ -1264,10 +2081,10 @@ 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_gid: Annotated[Optional[StrictStr], Field(description="The Pelias GID of an area to limit the search to.")] = None,
-        layers: Annotated[Optional[List[PeliasLayer]], Field(description="A list of layers to limit the search to.")] = None,
-        sources: Annotated[Optional[List[PeliasSource]], 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,
+        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,
         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[
@@ -1282,7 +2099,7 @@ class GeocodingApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> PeliasResponse:
+    ) -> GeocodeResponse:
         """Search for location and other info using a place name or address (forward geocoding).
 
         The search endpoint lets you search for addresses, points of interest, and administrative areas. This is most commonly used for forward geocoding applications where you need to find the geographic coordinates of an address.
@@ -1307,14 +2124,14 @@ 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 Pelias GID of an area to limit the search to.
+        :param boundary_gid: The GID of an area to limit the search to.
         :type boundary_gid: str
         :param layers: A list of layers to limit the search to.
-        :type layers: List[PeliasLayer]
+        :type layers: List[GeocodingLayer]
         :param sources: A list of sources to limit the search to.
-        :type sources: List[PeliasSource]
+        :type sources: List[GeocodingSource]
         :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.
@@ -1365,7 +2182,7 @@ class GeocodingApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PeliasResponse",
+            '200': "GeocodeResponse",
             '400': None,
         }
         response_data = self.api_client.call_api(
@@ -1392,10 +2209,10 @@ 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_gid: Annotated[Optional[StrictStr], Field(description="The Pelias GID of an area to limit the search to.")] = None,
-        layers: Annotated[Optional[List[PeliasLayer]], Field(description="A list of layers to limit the search to.")] = None,
-        sources: Annotated[Optional[List[PeliasSource]], 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,
+        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,
         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[
@@ -1410,7 +2227,7 @@ class GeocodingApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[PeliasResponse]:
+    ) -> ApiResponse[GeocodeResponse]:
         """Search for location and other info using a place name or address (forward geocoding).
 
         The search endpoint lets you search for addresses, points of interest, and administrative areas. This is most commonly used for forward geocoding applications where you need to find the geographic coordinates of an address.
@@ -1435,14 +2252,14 @@ 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 Pelias GID of an area to limit the search to.
+        :param boundary_gid: The GID of an area to limit the search to.
         :type boundary_gid: str
         :param layers: A list of layers to limit the search to.
-        :type layers: List[PeliasLayer]
+        :type layers: List[GeocodingLayer]
         :param sources: A list of sources to limit the search to.
-        :type sources: List[PeliasSource]
+        :type sources: List[GeocodingSource]
         :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.
@@ -1493,7 +2310,7 @@ class GeocodingApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PeliasResponse",
+            '200': "GeocodeResponse",
             '400': None,
         }
         response_data = self.api_client.call_api(
@@ -1520,10 +2337,10 @@ 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_gid: Annotated[Optional[StrictStr], Field(description="The Pelias GID of an area to limit the search to.")] = None,
-        layers: Annotated[Optional[List[PeliasLayer]], Field(description="A list of layers to limit the search to.")] = None,
-        sources: Annotated[Optional[List[PeliasSource]], 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,
+        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,
         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[
@@ -1563,14 +2380,14 @@ 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 Pelias GID of an area to limit the search to.
+        :param boundary_gid: The GID of an area to limit the search to.
         :type boundary_gid: str
         :param layers: A list of layers to limit the search to.
-        :type layers: List[PeliasLayer]
+        :type layers: List[GeocodingLayer]
         :param sources: A list of sources to limit the search to.
-        :type sources: List[PeliasSource]
+        :type sources: List[GeocodingSource]
         :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.
@@ -1621,7 +2438,7 @@ class GeocodingApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PeliasResponse",
+            '200': "GeocodeResponse",
             '400': None,
         }
         response_data = self.api_client.call_api(
@@ -1667,7 +2484,9 @@ class GeocodingApi:
         _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]] = {}
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
         _body_params: Optional[bytes] = None
 
         # process the path parameters
@@ -1992,7 +2811,9 @@ class GeocodingApi:
         _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]] = {}
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
         _body_params: Optional[bytes] = None
 
         # process the path parameters
@@ -2059,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,
@@ -2069,10 +2890,10 @@ 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_gid: Annotated[Optional[StrictStr], Field(description="The Pelias GID of an area to limit the search to.")] = None,
-        layers: Annotated[Optional[List[PeliasLayer]], Field(description="A list of layers to limit the search to.")] = None,
-        sources: Annotated[Optional[List[PeliasSource]], 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,
+        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,
         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[
@@ -2087,7 +2908,7 @@ class GeocodingApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> PeliasResponse:
+    ) -> GeocodeResponse:
         """Find locations matching components (structured forward geocoding).
 
         The structured search endpoint lets you search for addresses, points of interest, and administrative areas. Rather than a single string which the API must infer meaning from, the structured search endpoint allows you to specify the known components upfront, which is useful in many forward geocoding workflows.
@@ -2106,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
@@ -2126,14 +2947,14 @@ 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 Pelias GID of an area to limit the search to.
+        :param boundary_gid: The GID of an area to limit the search to.
         :type boundary_gid: str
         :param layers: A list of layers to limit the search to.
-        :type layers: List[PeliasLayer]
+        :type layers: List[GeocodingLayer]
         :param sources: A list of sources to limit the search to.
-        :type sources: List[PeliasSource]
+        :type sources: List[GeocodingSource]
         :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.
@@ -2191,7 +3012,7 @@ class GeocodingApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PeliasResponse",
+            '200': "GeocodeResponse",
             '400': None,
         }
         response_data = self.api_client.call_api(
@@ -2215,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,
@@ -2225,10 +3046,10 @@ 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_gid: Annotated[Optional[StrictStr], Field(description="The Pelias GID of an area to limit the search to.")] = None,
-        layers: Annotated[Optional[List[PeliasLayer]], Field(description="A list of layers to limit the search to.")] = None,
-        sources: Annotated[Optional[List[PeliasSource]], 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,
+        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,
         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[
@@ -2243,7 +3064,7 @@ class GeocodingApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[PeliasResponse]:
+    ) -> ApiResponse[GeocodeResponse]:
         """Find locations matching components (structured forward geocoding).
 
         The structured search endpoint lets you search for addresses, points of interest, and administrative areas. Rather than a single string which the API must infer meaning from, the structured search endpoint allows you to specify the known components upfront, which is useful in many forward geocoding workflows.
@@ -2262,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
@@ -2282,14 +3103,14 @@ 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 Pelias GID of an area to limit the search to.
+        :param boundary_gid: The GID of an area to limit the search to.
         :type boundary_gid: str
         :param layers: A list of layers to limit the search to.
-        :type layers: List[PeliasLayer]
+        :type layers: List[GeocodingLayer]
         :param sources: A list of sources to limit the search to.
-        :type sources: List[PeliasSource]
+        :type sources: List[GeocodingSource]
         :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.
@@ -2347,7 +3168,7 @@ class GeocodingApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PeliasResponse",
+            '200': "GeocodeResponse",
             '400': None,
         }
         response_data = self.api_client.call_api(
@@ -2371,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,
@@ -2381,10 +3202,10 @@ 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_gid: Annotated[Optional[StrictStr], Field(description="The Pelias GID of an area to limit the search to.")] = None,
-        layers: Annotated[Optional[List[PeliasLayer]], Field(description="A list of layers to limit the search to.")] = None,
-        sources: Annotated[Optional[List[PeliasSource]], 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,
+        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,
         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[
@@ -2418,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
@@ -2438,14 +3259,14 @@ 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 Pelias GID of an area to limit the search to.
+        :param boundary_gid: The GID of an area to limit the search to.
         :type boundary_gid: str
         :param layers: A list of layers to limit the search to.
-        :type layers: List[PeliasLayer]
+        :type layers: List[GeocodingLayer]
         :param sources: A list of sources to limit the search to.
-        :type sources: List[PeliasSource]
+        :type sources: List[GeocodingSource]
         :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.
@@ -2503,7 +3324,7 @@ class GeocodingApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PeliasResponse",
+            '200': "GeocodeResponse",
             '400': None,
         }
         response_data = self.api_client.call_api(
@@ -2556,7 +3377,9 @@ class GeocodingApi:
         _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]] = {}
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
         _body_params: Optional[bytes] = None
 
         # process the path parameters