@azure-rest/maps-search 2.0.0-beta.1 → 2.0.0-beta.3

package/dist/esm/generated/responses.d.ts

@@ -0,0 +1,255 @@
+import { RawHttpHeaders } from "@azure/core-rest-pipeline";
+import { HttpResponse } from "@azure-rest/core-client";
+import { GeocodingResponseOutput, ErrorResponseOutput, GeocodingBatchResponseOutput, BoundaryOutput } from "./outputModels.js";
+export interface SearchGetGeocoding200Headers {
+    /** request id. */
+    "x-ms-request-id"?: string;
+}
+/**
+ *
+ * The `Get Geocoding` API is an HTTP `GET` request that returns the longitude and latitude coordinates of the location being searched.
+ *
+ * In many cases, the complete search service might be too much, for instance if you are only interested in traditional geocoding. Search can also be accessed for address look up exclusively. The geocoding is performed by hitting the geocoding endpoint with just the address or partial address in question. The geocoding search index will be queried for everything above the street level data. No Point of Interest (POIs) will be returned. Note that the geocoder is very tolerant of typos and incomplete addresses. It will also handle everything from exact street addresses or street or intersections as well as higher level geographies such as city centers, counties and states. The response also returns detailed address properties such as street, postal code, municipality, and country/region information.
+ */
+export interface SearchGetGeocoding200Response extends HttpResponse {
+    status: "200";
+    body: GeocodingResponseOutput;
+    headers: RawHttpHeaders & SearchGetGeocoding200Headers;
+}
+/**
+ *
+ * The `Get Geocoding` API is an HTTP `GET` request that returns the longitude and latitude coordinates of the location being searched.
+ *
+ * In many cases, the complete search service might be too much, for instance if you are only interested in traditional geocoding. Search can also be accessed for address look up exclusively. The geocoding is performed by hitting the geocoding endpoint with just the address or partial address in question. The geocoding search index will be queried for everything above the street level data. No Point of Interest (POIs) will be returned. Note that the geocoder is very tolerant of typos and incomplete addresses. It will also handle everything from exact street addresses or street or intersections as well as higher level geographies such as city centers, counties and states. The response also returns detailed address properties such as street, postal code, municipality, and country/region information.
+ */
+export interface SearchGetGeocodingDefaultResponse extends HttpResponse {
+    status: string;
+    body: ErrorResponseOutput;
+}
+/**
+ *
+ * The `Get Geocoding Batch` API is an HTTP `POST` request that sends batches of up to **100** queries to the [Geocoding](/rest/api/maps/search/get-geocoding) API in a single request.
+ *
+ * ### Submit Synchronous Batch Request
+ * The Synchronous API is recommended for lightweight batch requests. When the service receives a request, it will respond as soon as the batch items are calculated and there will be no possibility to retrieve the results later. The Synchronous API will return a timeout error (a 408 response) if the request takes longer than 60 seconds. The number of batch items is limited to **100** for this API.
+ * ```
+ * POST https://atlas.microsoft.com/geocode:batch?api-version=2023-06-01
+ * ```
+ * ### POST Body for Batch Request
+ * To send the _geocoding_ queries you will use a `POST` request where the request body will contain the `batchItems` array in `json` format and the `Content-Type` header will be set to `application/json`. Here's a sample request body containing 2 _geocoding_ queries:
+ *
+ *
+ * ```
+ * {
+ *   "batchItems": [
+ *     {
+ *       "addressLine": "One, Microsoft Way, Redmond, WA 98052",
+ *       "top": 2
+ *     },
+ *     {
+ *       "addressLine": "Pike Pl",
+ *       "adminDistrict": "WA",
+ *       "locality": "Seattle",
+ *       "top": 3
+ *     }
+ *   ]
+ * }
+ * ```
+ *
+ * A _geocoding_ batchItem object can accept any of the supported _geocoding_ [URI parameters](/rest/api/maps/search/get-geocoding#uri-parameters).
+ *
+ *
+ * The batch should contain at least **1** query.
+ *
+ *
+ * ### Batch Response Model
+ * The batch response contains a `summary` component that indicates the `totalRequests` that were part of the original batch request and `successfulRequests` i.e. queries which were executed successfully. The batch response also includes a `batchItems` array which contains a response for each and every query in the batch request. The `batchItems` will contain the results in the exact same order the original queries were sent in the batch request. Each item is of one of the following types:
+ *
+ *   - [`GeocodingResponse`](/rest/api/maps/search/get-geocoding#geocodingresponse) - If the query completed successfully.
+ *
+ *   - `Error` - If the query failed. The response will contain a `code` and a `message` in this case.
+ *
+ *
+ *
+ */
+export interface SearchGetGeocodingBatch200Response extends HttpResponse {
+    status: "200";
+    body: GeocodingBatchResponseOutput;
+}
+/**
+ *
+ * The `Get Geocoding Batch` API is an HTTP `POST` request that sends batches of up to **100** queries to the [Geocoding](/rest/api/maps/search/get-geocoding) API in a single request.
+ *
+ * ### Submit Synchronous Batch Request
+ * The Synchronous API is recommended for lightweight batch requests. When the service receives a request, it will respond as soon as the batch items are calculated and there will be no possibility to retrieve the results later. The Synchronous API will return a timeout error (a 408 response) if the request takes longer than 60 seconds. The number of batch items is limited to **100** for this API.
+ * ```
+ * POST https://atlas.microsoft.com/geocode:batch?api-version=2023-06-01
+ * ```
+ * ### POST Body for Batch Request
+ * To send the _geocoding_ queries you will use a `POST` request where the request body will contain the `batchItems` array in `json` format and the `Content-Type` header will be set to `application/json`. Here's a sample request body containing 2 _geocoding_ queries:
+ *
+ *
+ * ```
+ * {
+ *   "batchItems": [
+ *     {
+ *       "addressLine": "One, Microsoft Way, Redmond, WA 98052",
+ *       "top": 2
+ *     },
+ *     {
+ *       "addressLine": "Pike Pl",
+ *       "adminDistrict": "WA",
+ *       "locality": "Seattle",
+ *       "top": 3
+ *     }
+ *   ]
+ * }
+ * ```
+ *
+ * A _geocoding_ batchItem object can accept any of the supported _geocoding_ [URI parameters](/rest/api/maps/search/get-geocoding#uri-parameters).
+ *
+ *
+ * The batch should contain at least **1** query.
+ *
+ *
+ * ### Batch Response Model
+ * The batch response contains a `summary` component that indicates the `totalRequests` that were part of the original batch request and `successfulRequests` i.e. queries which were executed successfully. The batch response also includes a `batchItems` array which contains a response for each and every query in the batch request. The `batchItems` will contain the results in the exact same order the original queries were sent in the batch request. Each item is of one of the following types:
+ *
+ *   - [`GeocodingResponse`](/rest/api/maps/search/get-geocoding#geocodingresponse) - If the query completed successfully.
+ *
+ *   - `Error` - If the query failed. The response will contain a `code` and a `message` in this case.
+ *
+ *
+ *
+ */
+export interface SearchGetGeocodingBatchDefaultResponse extends HttpResponse {
+    status: string;
+    body: ErrorResponseOutput;
+}
+/**
+ *
+ * The `Get Polygon` API is an HTTP `GET` request that supplies polygon data of a geographical area outline such as a city or a country region.
+ */
+export interface SearchGetPolygon200Response extends HttpResponse {
+    status: "200";
+    body: BoundaryOutput;
+}
+/**
+ *
+ * The `Get Polygon` API is an HTTP `GET` request that supplies polygon data of a geographical area outline such as a city or a country region.
+ */
+export interface SearchGetPolygonDefaultResponse extends HttpResponse {
+    status: string;
+    body: ErrorResponseOutput;
+}
+/**
+ *
+ * The `Get Reverse Geocoding` API is an HTTP `GET` request used to translate a coordinate (example: 37.786505, -122.3862) into a human understandable street address. Useful in tracking applications where you receive a GPS feed from the device or asset and wish to know the address associated with the coordinates. This endpoint will return address information for a given coordinate.
+ */
+export interface SearchGetReverseGeocoding200Response extends HttpResponse {
+    status: "200";
+    body: GeocodingResponseOutput;
+}
+/**
+ *
+ * The `Get Reverse Geocoding` API is an HTTP `GET` request used to translate a coordinate (example: 37.786505, -122.3862) into a human understandable street address. Useful in tracking applications where you receive a GPS feed from the device or asset and wish to know the address associated with the coordinates. This endpoint will return address information for a given coordinate.
+ */
+export interface SearchGetReverseGeocodingDefaultResponse extends HttpResponse {
+    status: string;
+    body: ErrorResponseOutput;
+}
+/**
+ *
+ * The `Get Reverse Geocoding Batch` API is an HTTP `POST` request that sends batches of up to **100** queries to [Reverse Geocoding](/rest/api/maps/search/get-reverse-geocoding) API using a single request.
+ *
+ * ### Submit Synchronous Batch Request
+ * The Synchronous API is recommended for lightweight batch requests. When the service receives a request, it will respond as soon as the batch items are calculated and there will be no possibility to retrieve the results later. The Synchronous API will return a timeout error (a 408 response) if the request takes longer than 60 seconds. The number of batch items is limited to **100** for this API.
+ * ```
+ * POST https://atlas.microsoft.com/reverseGeocode:batch?api-version=2023-06-01
+ * ```
+ * ### POST Body for Batch Request
+ * To send the _reverse geocoding_ queries you will use a `POST` request where the request body will contain the `batchItems` array in `json` format and the `Content-Type` header will be set to `application/json`. Here's a sample request body containing 2 _reverse geocoding_ queries:
+ *
+ *
+ * ```
+ * {
+ *   "batchItems": [
+ *     {
+ *       "coordinates": [-122.128275, 47.639429],
+ *       "resultTypes": ["Address", "PopulatedPlace"]
+ *     },
+ *     {
+ *       "coordinates": [-122.341979399674, 47.6095253501216]
+ *     }
+ *   ]
+ * }
+ * ```
+ *
+ * A _reverse geocoding_ batchItem object can accept any of the supported _reverse geocoding_ [URI parameters](/rest/api/maps/search/get-reverse-geocoding#uri-parameters).
+ *
+ *
+ * The batch should contain at least **1** query.
+ *
+ *
+ * ### Batch Response Model
+ * The batch response contains a `summary` component that indicates the `totalRequests` that were part of the original batch request and `successfulRequests` i.e. queries which were executed successfully. The batch response also includes a `batchItems` array which contains a response for each and every query in the batch request. The `batchItems` will contain the results in the exact same order the original queries were sent in the batch request. Each item is of one of the following types:
+ *
+ *   - [`GeocodingResponse`](/rest/api/maps/search/get-reverse-geocoding#geocodingresponse) - If the query completed successfully.
+ *
+ *   - `Error` - If the query failed. The response will contain a `code` and a `message` in this case.
+ *
+ *
+ *
+ */
+export interface SearchGetReverseGeocodingBatch200Response extends HttpResponse {
+    status: "200";
+    body: GeocodingBatchResponseOutput;
+}
+/**
+ *
+ * The `Get Reverse Geocoding Batch` API is an HTTP `POST` request that sends batches of up to **100** queries to [Reverse Geocoding](/rest/api/maps/search/get-reverse-geocoding) API using a single request.
+ *
+ * ### Submit Synchronous Batch Request
+ * The Synchronous API is recommended for lightweight batch requests. When the service receives a request, it will respond as soon as the batch items are calculated and there will be no possibility to retrieve the results later. The Synchronous API will return a timeout error (a 408 response) if the request takes longer than 60 seconds. The number of batch items is limited to **100** for this API.
+ * ```
+ * POST https://atlas.microsoft.com/reverseGeocode:batch?api-version=2023-06-01
+ * ```
+ * ### POST Body for Batch Request
+ * To send the _reverse geocoding_ queries you will use a `POST` request where the request body will contain the `batchItems` array in `json` format and the `Content-Type` header will be set to `application/json`. Here's a sample request body containing 2 _reverse geocoding_ queries:
+ *
+ *
+ * ```
+ * {
+ *   "batchItems": [
+ *     {
+ *       "coordinates": [-122.128275, 47.639429],
+ *       "resultTypes": ["Address", "PopulatedPlace"]
+ *     },
+ *     {
+ *       "coordinates": [-122.341979399674, 47.6095253501216]
+ *     }
+ *   ]
+ * }
+ * ```
+ *
+ * A _reverse geocoding_ batchItem object can accept any of the supported _reverse geocoding_ [URI parameters](/rest/api/maps/search/get-reverse-geocoding#uri-parameters).
+ *
+ *
+ * The batch should contain at least **1** query.
+ *
+ *
+ * ### Batch Response Model
+ * The batch response contains a `summary` component that indicates the `totalRequests` that were part of the original batch request and `successfulRequests` i.e. queries which were executed successfully. The batch response also includes a `batchItems` array which contains a response for each and every query in the batch request. The `batchItems` will contain the results in the exact same order the original queries were sent in the batch request. Each item is of one of the following types:
+ *
+ *   - [`GeocodingResponse`](/rest/api/maps/search/get-reverse-geocoding#geocodingresponse) - If the query completed successfully.
+ *
+ *   - `Error` - If the query failed. The response will contain a `code` and a `message` in this case.
+ *
+ *
+ *
+ */
+export interface SearchGetReverseGeocodingBatchDefaultResponse extends HttpResponse {
+    status: string;
+    body: ErrorResponseOutput;
+}
+//# sourceMappingURL=responses.d.ts.map

package/dist/esm/generated/responses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responses.d.ts","sourceRoot":"","sources":["../../../src/generated/responses.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EACL,uBAAuB,EACvB,mBAAmB,EACnB,4BAA4B,EAC5B,cAAc,EACf,MAAM,mBAAmB,CAAC;AAE3B,MAAM,WAAW,4BAA4B;IAC3C,kBAAkB;IAClB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;GAKG;AACH,MAAM,WAAW,6BAA8B,SAAQ,YAAY;IACjE,MAAM,EAAE,KAAK,CAAC;IACd,IAAI,EAAE,uBAAuB,CAAC;IAC9B,OAAO,EAAE,cAAc,GAAG,4BAA4B,CAAC;CACxD;AAED;;;;;GAKG;AACH,MAAM,WAAW,iCAAkC,SAAQ,YAAY;IACrE,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,mBAAmB,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,WAAW,kCAAmC,SAAQ,YAAY;IACtE,MAAM,EAAE,KAAK,CAAC;IACd,IAAI,EAAE,4BAA4B,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,WAAW,sCAAuC,SAAQ,YAAY;IAC1E,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,mBAAmB,CAAC;CAC3B;AAED;;;GAGG;AACH,MAAM,WAAW,2BAA4B,SAAQ,YAAY;IAC/D,MAAM,EAAE,KAAK,CAAC;IACd,IAAI,EAAE,cAAc,CAAC;CACtB;AAED;;;GAGG;AACH,MAAM,WAAW,+BAAgC,SAAQ,YAAY;IACnE,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,mBAAmB,CAAC;CAC3B;AAED;;;GAGG;AACH,MAAM,WAAW,oCAAqC,SAAQ,YAAY;IACxE,MAAM,EAAE,KAAK,CAAC;IACd,IAAI,EAAE,uBAAuB,CAAC;CAC/B;AAED;;;GAGG;AACH,MAAM,WAAW,wCAAyC,SAAQ,YAAY;IAC5E,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,mBAAmB,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,WAAW,yCACf,SAAQ,YAAY;IACpB,MAAM,EAAE,KAAK,CAAC;IACd,IAAI,EAAE,4BAA4B,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,WAAW,6CACf,SAAQ,YAAY;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,mBAAmB,CAAC;CAC3B"}

package/dist/esm/generated/responses.js

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+export {};
+//# sourceMappingURL=responses.js.map

package/dist/esm/generated/responses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"responses.js","sourceRoot":"","sources":["../../../src/generated/responses.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport { RawHttpHeaders } from \"@azure/core-rest-pipeline\";\nimport { HttpResponse } from \"@azure-rest/core-client\";\nimport {\n  GeocodingResponseOutput,\n  ErrorResponseOutput,\n  GeocodingBatchResponseOutput,\n  BoundaryOutput,\n} from \"./outputModels.js\";\n\nexport interface SearchGetGeocoding200Headers {\n  /** request id. */\n  \"x-ms-request-id\"?: string;\n}\n\n/**\n *\n * The `Get Geocoding` API is an HTTP `GET` request that returns the longitude and latitude coordinates of the location being searched.\n *\n * In many cases, the complete search service might be too much, for instance if you are only interested in traditional geocoding. Search can also be accessed for address look up exclusively. The geocoding is performed by hitting the geocoding endpoint with just the address or partial address in question. The geocoding search index will be queried for everything above the street level data. No Point of Interest (POIs) will be returned. Note that the geocoder is very tolerant of typos and incomplete addresses. It will also handle everything from exact street addresses or street or intersections as well as higher level geographies such as city centers, counties and states. The response also returns detailed address properties such as street, postal code, municipality, and country/region information.\n */\nexport interface SearchGetGeocoding200Response extends HttpResponse {\n  status: \"200\";\n  body: GeocodingResponseOutput;\n  headers: RawHttpHeaders & SearchGetGeocoding200Headers;\n}\n\n/**\n *\n * The `Get Geocoding` API is an HTTP `GET` request that returns the longitude and latitude coordinates of the location being searched.\n *\n * In many cases, the complete search service might be too much, for instance if you are only interested in traditional geocoding. Search can also be accessed for address look up exclusively. The geocoding is performed by hitting the geocoding endpoint with just the address or partial address in question. The geocoding search index will be queried for everything above the street level data. No Point of Interest (POIs) will be returned. Note that the geocoder is very tolerant of typos and incomplete addresses. It will also handle everything from exact street addresses or street or intersections as well as higher level geographies such as city centers, counties and states. The response also returns detailed address properties such as street, postal code, municipality, and country/region information.\n */\nexport interface SearchGetGeocodingDefaultResponse extends HttpResponse {\n  status: string;\n  body: ErrorResponseOutput;\n}\n\n/**\n *\n * The `Get Geocoding Batch` API is an HTTP `POST` request that sends batches of up to **100** queries to the [Geocoding](/rest/api/maps/search/get-geocoding) API in a single request.\n *\n * ### Submit Synchronous Batch Request\n * The Synchronous API is recommended for lightweight batch requests. When the service receives a request, it will respond as soon as the batch items are calculated and there will be no possibility to retrieve the results later. The Synchronous API will return a timeout error (a 408 response) if the request takes longer than 60 seconds. The number of batch items is limited to **100** for this API.\n * ```\n * POST https://atlas.microsoft.com/geocode:batch?api-version=2023-06-01\n * ```\n * ### POST Body for Batch Request\n * To send the _geocoding_ queries you will use a `POST` request where the request body will contain the `batchItems` array in `json` format and the `Content-Type` header will be set to `application/json`. Here's a sample request body containing 2 _geocoding_ queries:\n *\n *\n * ```\n * {\n *   \"batchItems\": [\n *     {\n *       \"addressLine\": \"One, Microsoft Way, Redmond, WA 98052\",\n *       \"top\": 2\n *     },\n *     {\n *       \"addressLine\": \"Pike Pl\",\n *       \"adminDistrict\": \"WA\",\n *       \"locality\": \"Seattle\",\n *       \"top\": 3\n *     }\n *   ]\n * }\n * ```\n *\n * A _geocoding_ batchItem object can accept any of the supported _geocoding_ [URI parameters](/rest/api/maps/search/get-geocoding#uri-parameters).\n *\n *\n * The batch should contain at least **1** query.\n *\n *\n * ### Batch Response Model\n * The batch response contains a `summary` component that indicates the `totalRequests` that were part of the original batch request and `successfulRequests` i.e. queries which were executed successfully. The batch response also includes a `batchItems` array which contains a response for each and every query in the batch request. The `batchItems` will contain the results in the exact same order the original queries were sent in the batch request. Each item is of one of the following types:\n *\n *   - [`GeocodingResponse`](/rest/api/maps/search/get-geocoding#geocodingresponse) - If the query completed successfully.\n *\n *   - `Error` - If the query failed. The response will contain a `code` and a `message` in this case.\n *\n *\n *\n */\nexport interface SearchGetGeocodingBatch200Response extends HttpResponse {\n  status: \"200\";\n  body: GeocodingBatchResponseOutput;\n}\n\n/**\n *\n * The `Get Geocoding Batch` API is an HTTP `POST` request that sends batches of up to **100** queries to the [Geocoding](/rest/api/maps/search/get-geocoding) API in a single request.\n *\n * ### Submit Synchronous Batch Request\n * The Synchronous API is recommended for lightweight batch requests. When the service receives a request, it will respond as soon as the batch items are calculated and there will be no possibility to retrieve the results later. The Synchronous API will return a timeout error (a 408 response) if the request takes longer than 60 seconds. The number of batch items is limited to **100** for this API.\n * ```\n * POST https://atlas.microsoft.com/geocode:batch?api-version=2023-06-01\n * ```\n * ### POST Body for Batch Request\n * To send the _geocoding_ queries you will use a `POST` request where the request body will contain the `batchItems` array in `json` format and the `Content-Type` header will be set to `application/json`. Here's a sample request body containing 2 _geocoding_ queries:\n *\n *\n * ```\n * {\n *   \"batchItems\": [\n *     {\n *       \"addressLine\": \"One, Microsoft Way, Redmond, WA 98052\",\n *       \"top\": 2\n *     },\n *     {\n *       \"addressLine\": \"Pike Pl\",\n *       \"adminDistrict\": \"WA\",\n *       \"locality\": \"Seattle\",\n *       \"top\": 3\n *     }\n *   ]\n * }\n * ```\n *\n * A _geocoding_ batchItem object can accept any of the supported _geocoding_ [URI parameters](/rest/api/maps/search/get-geocoding#uri-parameters).\n *\n *\n * The batch should contain at least **1** query.\n *\n *\n * ### Batch Response Model\n * The batch response contains a `summary` component that indicates the `totalRequests` that were part of the original batch request and `successfulRequests` i.e. queries which were executed successfully. The batch response also includes a `batchItems` array which contains a response for each and every query in the batch request. The `batchItems` will contain the results in the exact same order the original queries were sent in the batch request. Each item is of one of the following types:\n *\n *   - [`GeocodingResponse`](/rest/api/maps/search/get-geocoding#geocodingresponse) - If the query completed successfully.\n *\n *   - `Error` - If the query failed. The response will contain a `code` and a `message` in this case.\n *\n *\n *\n */\nexport interface SearchGetGeocodingBatchDefaultResponse extends HttpResponse {\n  status: string;\n  body: ErrorResponseOutput;\n}\n\n/**\n *\n * The `Get Polygon` API is an HTTP `GET` request that supplies polygon data of a geographical area outline such as a city or a country region.\n */\nexport interface SearchGetPolygon200Response extends HttpResponse {\n  status: \"200\";\n  body: BoundaryOutput;\n}\n\n/**\n *\n * The `Get Polygon` API is an HTTP `GET` request that supplies polygon data of a geographical area outline such as a city or a country region.\n */\nexport interface SearchGetPolygonDefaultResponse extends HttpResponse {\n  status: string;\n  body: ErrorResponseOutput;\n}\n\n/**\n *\n * The `Get Reverse Geocoding` API is an HTTP `GET` request used to translate a coordinate (example: 37.786505, -122.3862) into a human understandable street address. Useful in tracking applications where you receive a GPS feed from the device or asset and wish to know the address associated with the coordinates. This endpoint will return address information for a given coordinate.\n */\nexport interface SearchGetReverseGeocoding200Response extends HttpResponse {\n  status: \"200\";\n  body: GeocodingResponseOutput;\n}\n\n/**\n *\n * The `Get Reverse Geocoding` API is an HTTP `GET` request used to translate a coordinate (example: 37.786505, -122.3862) into a human understandable street address. Useful in tracking applications where you receive a GPS feed from the device or asset and wish to know the address associated with the coordinates. This endpoint will return address information for a given coordinate.\n */\nexport interface SearchGetReverseGeocodingDefaultResponse extends HttpResponse {\n  status: string;\n  body: ErrorResponseOutput;\n}\n\n/**\n *\n * The `Get Reverse Geocoding Batch` API is an HTTP `POST` request that sends batches of up to **100** queries to [Reverse Geocoding](/rest/api/maps/search/get-reverse-geocoding) API using a single request.\n *\n * ### Submit Synchronous Batch Request\n * The Synchronous API is recommended for lightweight batch requests. When the service receives a request, it will respond as soon as the batch items are calculated and there will be no possibility to retrieve the results later. The Synchronous API will return a timeout error (a 408 response) if the request takes longer than 60 seconds. The number of batch items is limited to **100** for this API.\n * ```\n * POST https://atlas.microsoft.com/reverseGeocode:batch?api-version=2023-06-01\n * ```\n * ### POST Body for Batch Request\n * To send the _reverse geocoding_ queries you will use a `POST` request where the request body will contain the `batchItems` array in `json` format and the `Content-Type` header will be set to `application/json`. Here's a sample request body containing 2 _reverse geocoding_ queries:\n *\n *\n * ```\n * {\n *   \"batchItems\": [\n *     {\n *       \"coordinates\": [-122.128275, 47.639429],\n *       \"resultTypes\": [\"Address\", \"PopulatedPlace\"]\n *     },\n *     {\n *       \"coordinates\": [-122.341979399674, 47.6095253501216]\n *     }\n *   ]\n * }\n * ```\n *\n * A _reverse geocoding_ batchItem object can accept any of the supported _reverse geocoding_ [URI parameters](/rest/api/maps/search/get-reverse-geocoding#uri-parameters).\n *\n *\n * The batch should contain at least **1** query.\n *\n *\n * ### Batch Response Model\n * The batch response contains a `summary` component that indicates the `totalRequests` that were part of the original batch request and `successfulRequests` i.e. queries which were executed successfully. The batch response also includes a `batchItems` array which contains a response for each and every query in the batch request. The `batchItems` will contain the results in the exact same order the original queries were sent in the batch request. Each item is of one of the following types:\n *\n *   - [`GeocodingResponse`](/rest/api/maps/search/get-reverse-geocoding#geocodingresponse) - If the query completed successfully.\n *\n *   - `Error` - If the query failed. The response will contain a `code` and a `message` in this case.\n *\n *\n *\n */\nexport interface SearchGetReverseGeocodingBatch200Response\n  extends HttpResponse {\n  status: \"200\";\n  body: GeocodingBatchResponseOutput;\n}\n\n/**\n *\n * The `Get Reverse Geocoding Batch` API is an HTTP `POST` request that sends batches of up to **100** queries to [Reverse Geocoding](/rest/api/maps/search/get-reverse-geocoding) API using a single request.\n *\n * ### Submit Synchronous Batch Request\n * The Synchronous API is recommended for lightweight batch requests. When the service receives a request, it will respond as soon as the batch items are calculated and there will be no possibility to retrieve the results later. The Synchronous API will return a timeout error (a 408 response) if the request takes longer than 60 seconds. The number of batch items is limited to **100** for this API.\n * ```\n * POST https://atlas.microsoft.com/reverseGeocode:batch?api-version=2023-06-01\n * ```\n * ### POST Body for Batch Request\n * To send the _reverse geocoding_ queries you will use a `POST` request where the request body will contain the `batchItems` array in `json` format and the `Content-Type` header will be set to `application/json`. Here's a sample request body containing 2 _reverse geocoding_ queries:\n *\n *\n * ```\n * {\n *   \"batchItems\": [\n *     {\n *       \"coordinates\": [-122.128275, 47.639429],\n *       \"resultTypes\": [\"Address\", \"PopulatedPlace\"]\n *     },\n *     {\n *       \"coordinates\": [-122.341979399674, 47.6095253501216]\n *     }\n *   ]\n * }\n * ```\n *\n * A _reverse geocoding_ batchItem object can accept any of the supported _reverse geocoding_ [URI parameters](/rest/api/maps/search/get-reverse-geocoding#uri-parameters).\n *\n *\n * The batch should contain at least **1** query.\n *\n *\n * ### Batch Response Model\n * The batch response contains a `summary` component that indicates the `totalRequests` that were part of the original batch request and `successfulRequests` i.e. queries which were executed successfully. The batch response also includes a `batchItems` array which contains a response for each and every query in the batch request. The `batchItems` will contain the results in the exact same order the original queries were sent in the batch request. Each item is of one of the following types:\n *\n *   - [`GeocodingResponse`](/rest/api/maps/search/get-reverse-geocoding#geocodingresponse) - If the query completed successfully.\n *\n *   - `Error` - If the query failed. The response will contain a `code` and a `message` in this case.\n *\n *\n *\n */\nexport interface SearchGetReverseGeocodingBatchDefaultResponse\n  extends HttpResponse {\n  status: string;\n  body: ErrorResponseOutput;\n}\n"]}

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+import MapsSearch from "./MapsSearch.js";
+export * from "./generated/index.js";
+export default MapsSearch;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,UAAU,MAAM,iBAAiB,CAAC;AAEzC,cAAc,sBAAsB,CAAC;AACrC,eAAe,UAAU,CAAC"}

package/dist/esm/index.js

@@ -0,0 +1,6 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import MapsSearch from "./MapsSearch.js";
+export * from "./generated/index.js";
+export default MapsSearch;
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAElC,OAAO,UAAU,MAAM,iBAAiB,CAAC;AAEzC,cAAc,sBAAsB,CAAC;AACrC,eAAe,UAAU,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport MapsSearch from \"./MapsSearch.js\";\n\nexport * from \"./generated/index.js\";\nexport default MapsSearch;\n"]}

package/dist/esm/logger.d.ts

@@ -0,0 +1,2 @@
+export declare const logger: import("@azure/logger").AzureLogger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/esm/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/logger.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,MAAM,qCAAoC,CAAC"}

package/dist/esm/logger.js

@@ -0,0 +1,5 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { createClientLogger } from "@azure/logger";
+export const logger = createClientLogger("maps-search");
+//# sourceMappingURL=logger.js.map

package/dist/esm/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../src/logger.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAElC,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACnD,MAAM,CAAC,MAAM,MAAM,GAAG,kBAAkB,CAAC,aAAa,CAAC,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport { createClientLogger } from \"@azure/logger\";\nexport const logger = createClientLogger(\"maps-search\");\n"]}

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/react-native/MapsSearch.d.ts

@@ -0,0 +1,53 @@
+import type { ClientOptions } from "@azure-rest/core-client";
+import type { AzureKeyCredential, AzureSASCredential, TokenCredential } from "@azure/core-auth";
+import type { MapsSearchClient } from "./generated/index.js";
+/**
+ * Creates an instance of MapsSearchClient from a subscription key.
+ *
+ * @example
+ * ```ts snippet:ReadmeSampleCreateClient_SubscriptionKey
+ * import { AzureKeyCredential } from "@azure/core-auth";
+ * import MapsSearch from "@azure-rest/maps-search";
+ *
+ * const credential = new AzureKeyCredential("<subscription-key>");
+ * const client = MapsSearch(credential);
+ *```
+ *
+ * @param credential - An AzureKeyCredential instance used to authenticate requests to the service
+ * @param options - Options used to configure the Search Client
+ */
+export default function MapsSearch(credential: AzureKeyCredential, options?: ClientOptions): MapsSearchClient;
+/**
+ * Creates an instance of MapsSearch from an Azure Identity `TokenCredential`.
+ *
+ * @example
+ * ```ts snippet:ReadmeSampleCreateClient_TokenCredential
+ * import { DefaultAzureCredential } from "@azure/identity";
+ * import MapsSearch from "@azure-rest/maps-search";
+ *
+ * const credential = new DefaultAzureCredential();
+ * const client = MapsSearch(credential, "<maps-account-client-id>");
+ *```
+ *
+ * @param credential - An TokenCredential instance used to authenticate requests to the service
+ * @param mapsAccountClientId - The Azure Maps client id of a specific map resource
+ * @param options - Options used to configure the Search Client
+ */
+export default function MapsSearch(credential: TokenCredential, mapsAccountClientId: string, options?: ClientOptions): MapsSearchClient;
+/**
+ * Creates an instance of MapsSearch from an Azure Identity `AzureSASCredential`.
+ *
+ * @example
+ * ```ts snippet:ReadmeSampleCreateClient_SASToken
+ * import { AzureSASCredential } from "@azure/core-auth";
+ * import MapsSearch from "@azure-rest/maps-search";
+ *
+ * const credential = new AzureSASCredential("<SAS Token>");
+ * const client = MapsSearch(credential);
+ * ```
+ *
+ * @param credential - An AzureSASCredential instance used to authenticate requests to the service
+ * @param options - Options used to configure the Search Client
+ */
+export default function MapsSearch(credential: AzureSASCredential, options?: ClientOptions): MapsSearchClient;
+//# sourceMappingURL=MapsSearch.d.ts.map

package/dist/react-native/MapsSearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapsSearch.d.ts","sourceRoot":"","sources":["../../src/MapsSearch.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAGhG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAI7D;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,UAAU,EAAE,kBAAkB,EAC9B,OAAO,CAAC,EAAE,aAAa,GACtB,gBAAgB,CAAC;AACpB;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,UAAU,EAAE,eAAe,EAC3B,mBAAmB,EAAE,MAAM,EAC3B,OAAO,CAAC,EAAE,aAAa,GACtB,gBAAgB,CAAC;AACpB;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,UAAU,EAAE,kBAAkB,EAC9B,OAAO,CAAC,EAAE,aAAa,GACtB,gBAAgB,CAAC"}

package/dist/react-native/MapsSearch.js

@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { isSASCredential, isTokenCredential } from "@azure/core-auth";
+import { createMapsClientIdPolicy } from "@azure/maps-common";
+import createClient from "./generated/index.js";
+import { bearerTokenAuthenticationPolicy } from "@azure/core-rest-pipeline";
+export default function MapsSearch(credential, clientIdOrOptions = {}, maybeOptions = {}) {
+    const options = typeof clientIdOrOptions === "string" ? maybeOptions : clientIdOrOptions;
+    /**
+     * maps service requires a header "ms-x-client-id", which is different from the standard Microsoft Entra ID.
+     * So we need to do our own implementation.
+     * This customized authentication is following by this guide: https://github.com/Azure/azure-sdk-for-js/blob/main/documentation/RLC-customization.md#custom-authentication
+     */
+    if (isTokenCredential(credential)) {
+        const clientId = typeof clientIdOrOptions === "string" ? clientIdOrOptions : "";
+        if (!clientId) {
+            throw Error("Client id is needed for TokenCredential");
+        }
+        const client = createClient(undefined, options);
+        client.pipeline.addPolicy(bearerTokenAuthenticationPolicy({
+            credential,
+            scopes: "https://atlas.microsoft.com/.default",
+        }));
+        client.pipeline.addPolicy(createMapsClientIdPolicy(clientId));
+        return client;
+    }
+    if (isSASCredential(credential)) {
+        const client = createClient(undefined, options);
+        client.pipeline.addPolicy({
+            name: "mapsSASCredentialPolicy",
+            async sendRequest(request, next) {
+                request.headers.set("Authorization", `jwt-sas ${credential.signature}`);
+                return next(request);
+            },
+        });
+        return client;
+    }
+    return createClient(credential, options);
+}
+//# sourceMappingURL=MapsSearch.js.map

package/dist/react-native/MapsSearch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapsSearch.js","sourceRoot":"","sources":["../../src/MapsSearch.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAIlC,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,YAAY,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,+BAA+B,EAAE,MAAM,2BAA2B,CAAC;AA6D5E,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,UAAqE,EACrE,oBAA4C,EAAE,EAC9C,eAA8B,EAAE;IAEhC,MAAM,OAAO,GAAG,OAAO,iBAAiB,KAAK,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,iBAAiB,CAAC;IAEzF;;;;OAIG;IACH,IAAI,iBAAiB,CAAC,UAAU,CAAC,EAAE,CAAC;QAClC,MAAM,QAAQ,GAAG,OAAO,iBAAiB,KAAK,QAAQ,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,CAAC;QAChF,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,MAAM,KAAK,CAAC,yCAAyC,CAAC,CAAC;QACzD,CAAC;QACD,MAAM,MAAM,GAAG,YAAY,CAAC,SAAgB,EAAE,OAAO,CAAC,CAAC;QACvD,MAAM,CAAC,QAAQ,CAAC,SAAS,CACvB,+BAA+B,CAAC;YAC9B,UAAU;YACV,MAAM,EAAE,sCAAsC;SAC/C,CAAC,CACH,CAAC;QACF,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,wBAAwB,CAAC,QAAQ,CAAC,CAAC,CAAC;QAC9D,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,IAAI,eAAe,CAAC,UAAU,CAAC,EAAE,CAAC;QAChC,MAAM,MAAM,GAAG,YAAY,CAAC,SAAgB,EAAE,OAAO,CAAC,CAAC;QACvD,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC;YACxB,IAAI,EAAE,yBAAyB;YAC/B,KAAK,CAAC,WAAW,CAAC,OAAO,EAAE,IAAI;gBAC7B,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,WAAW,UAAU,CAAC,SAAS,EAAE,CAAC,CAAC;gBACxE,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC;YACvB,CAAC;SACF,CAAC,CAAC;QACH,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,OAAO,YAAY,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;AAC3C,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { ClientOptions } from \"@azure-rest/core-client\";\nimport type { AzureKeyCredential, AzureSASCredential, TokenCredential } from \"@azure/core-auth\";\nimport { isSASCredential, isTokenCredential } from \"@azure/core-auth\";\nimport { createMapsClientIdPolicy } from \"@azure/maps-common\";\nimport type { MapsSearchClient } from \"./generated/index.js\";\nimport createClient from \"./generated/index.js\";\nimport { bearerTokenAuthenticationPolicy } from \"@azure/core-rest-pipeline\";\n\n/**\n * Creates an instance of MapsSearchClient from a subscription key.\n *\n * @example\n * ```ts snippet:ReadmeSampleCreateClient_SubscriptionKey\n * import { AzureKeyCredential } from \"@azure/core-auth\";\n * import MapsSearch from \"@azure-rest/maps-search\";\n *\n * const credential = new AzureKeyCredential(\"<subscription-key>\");\n * const client = MapsSearch(credential);\n *```\n *\n * @param credential - An AzureKeyCredential instance used to authenticate requests to the service\n * @param options - Options used to configure the Search Client\n */\nexport default function MapsSearch(\n  credential: AzureKeyCredential,\n  options?: ClientOptions,\n): MapsSearchClient;\n/**\n * Creates an instance of MapsSearch from an Azure Identity `TokenCredential`.\n *\n * @example\n * ```ts snippet:ReadmeSampleCreateClient_TokenCredential\n * import { DefaultAzureCredential } from \"@azure/identity\";\n * import MapsSearch from \"@azure-rest/maps-search\";\n *\n * const credential = new DefaultAzureCredential();\n * const client = MapsSearch(credential, \"<maps-account-client-id>\");\n *```\n *\n * @param credential - An TokenCredential instance used to authenticate requests to the service\n * @param mapsAccountClientId - The Azure Maps client id of a specific map resource\n * @param options - Options used to configure the Search Client\n */\nexport default function MapsSearch(\n  credential: TokenCredential,\n  mapsAccountClientId: string,\n  options?: ClientOptions,\n): MapsSearchClient;\n/**\n * Creates an instance of MapsSearch from an Azure Identity `AzureSASCredential`.\n *\n * @example\n * ```ts snippet:ReadmeSampleCreateClient_SASToken\n * import { AzureSASCredential } from \"@azure/core-auth\";\n * import MapsSearch from \"@azure-rest/maps-search\";\n *\n * const credential = new AzureSASCredential(\"<SAS Token>\");\n * const client = MapsSearch(credential);\n * ```\n *\n * @param credential - An AzureSASCredential instance used to authenticate requests to the service\n * @param options - Options used to configure the Search Client\n */\nexport default function MapsSearch(\n  credential: AzureSASCredential,\n  options?: ClientOptions,\n): MapsSearchClient;\nexport default function MapsSearch(\n  credential: TokenCredential | AzureKeyCredential | AzureSASCredential,\n  clientIdOrOptions: string | ClientOptions = {},\n  maybeOptions: ClientOptions = {},\n): MapsSearchClient {\n  const options = typeof clientIdOrOptions === \"string\" ? maybeOptions : clientIdOrOptions;\n\n  /**\n   * maps service requires a header \"ms-x-client-id\", which is different from the standard Microsoft Entra ID.\n   * So we need to do our own implementation.\n   * This customized authentication is following by this guide: https://github.com/Azure/azure-sdk-for-js/blob/main/documentation/RLC-customization.md#custom-authentication\n   */\n  if (isTokenCredential(credential)) {\n    const clientId = typeof clientIdOrOptions === \"string\" ? clientIdOrOptions : \"\";\n    if (!clientId) {\n      throw Error(\"Client id is needed for TokenCredential\");\n    }\n    const client = createClient(undefined as any, options);\n    client.pipeline.addPolicy(\n      bearerTokenAuthenticationPolicy({\n        credential,\n        scopes: \"https://atlas.microsoft.com/.default\",\n      }),\n    );\n    client.pipeline.addPolicy(createMapsClientIdPolicy(clientId));\n    return client;\n  }\n\n  if (isSASCredential(credential)) {\n    const client = createClient(undefined as any, options);\n    client.pipeline.addPolicy({\n      name: \"mapsSASCredentialPolicy\",\n      async sendRequest(request, next) {\n        request.headers.set(\"Authorization\", `jwt-sas ${credential.signature}`);\n        return next(request);\n      },\n    });\n    return client;\n  }\n\n  return createClient(credential, options);\n}\n"]}

package/dist/react-native/generated/clientDefinitions.d.ts

@@ -0,0 +1,137 @@
+import { SearchGetGeocodingParameters, SearchGetGeocodingBatchParameters, SearchGetPolygonParameters, SearchGetReverseGeocodingParameters, SearchGetReverseGeocodingBatchParameters } from "./parameters.js";
+import { SearchGetGeocoding200Response, SearchGetGeocodingDefaultResponse, SearchGetGeocodingBatch200Response, SearchGetGeocodingBatchDefaultResponse, SearchGetPolygon200Response, SearchGetPolygonDefaultResponse, SearchGetReverseGeocoding200Response, SearchGetReverseGeocodingDefaultResponse, SearchGetReverseGeocodingBatch200Response, SearchGetReverseGeocodingBatchDefaultResponse } from "./responses.js";
+import { Client, StreamableMethod } from "@azure-rest/core-client";
+export interface GetGeocoding {
+    /**
+     *
+     * The `Get Geocoding` API is an HTTP `GET` request that returns the longitude and latitude coordinates of the location being searched.
+     *
+     * In many cases, the complete search service might be too much, for instance if you are only interested in traditional geocoding. Search can also be accessed for address look up exclusively. The geocoding is performed by hitting the geocoding endpoint with just the address or partial address in question. The geocoding search index will be queried for everything above the street level data. No Point of Interest (POIs) will be returned. Note that the geocoder is very tolerant of typos and incomplete addresses. It will also handle everything from exact street addresses or street or intersections as well as higher level geographies such as city centers, counties and states. The response also returns detailed address properties such as street, postal code, municipality, and country/region information.
+     */
+    get(options?: SearchGetGeocodingParameters): StreamableMethod<SearchGetGeocoding200Response | SearchGetGeocodingDefaultResponse>;
+}
+export interface GetGeocodingBatch {
+    /**
+     *
+     * The `Get Geocoding Batch` API is an HTTP `POST` request that sends batches of up to **100** queries to the [Geocoding](/rest/api/maps/search/get-geocoding) API in a single request.
+     *
+     * ### Submit Synchronous Batch Request
+     * The Synchronous API is recommended for lightweight batch requests. When the service receives a request, it will respond as soon as the batch items are calculated and there will be no possibility to retrieve the results later. The Synchronous API will return a timeout error (a 408 response) if the request takes longer than 60 seconds. The number of batch items is limited to **100** for this API.
+     * ```
+     * POST https://atlas.microsoft.com/geocode:batch?api-version=2023-06-01
+     * ```
+     * ### POST Body for Batch Request
+     * To send the _geocoding_ queries you will use a `POST` request where the request body will contain the `batchItems` array in `json` format and the `Content-Type` header will be set to `application/json`. Here's a sample request body containing 2 _geocoding_ queries:
+     *
+     *
+     * ```
+     * {
+     *   "batchItems": [
+     *     {
+     *       "addressLine": "One, Microsoft Way, Redmond, WA 98052",
+     *       "top": 2
+     *     },
+     *     {
+     *       "addressLine": "Pike Pl",
+     *       "adminDistrict": "WA",
+     *       "locality": "Seattle",
+     *       "top": 3
+     *     }
+     *   ]
+     * }
+     * ```
+     *
+     * A _geocoding_ batchItem object can accept any of the supported _geocoding_ [URI parameters](/rest/api/maps/search/get-geocoding#uri-parameters).
+     *
+     *
+     * The batch should contain at least **1** query.
+     *
+     *
+     * ### Batch Response Model
+     * The batch response contains a `summary` component that indicates the `totalRequests` that were part of the original batch request and `successfulRequests` i.e. queries which were executed successfully. The batch response also includes a `batchItems` array which contains a response for each and every query in the batch request. The `batchItems` will contain the results in the exact same order the original queries were sent in the batch request. Each item is of one of the following types:
+     *
+     *   - [`GeocodingResponse`](/rest/api/maps/search/get-geocoding#geocodingresponse) - If the query completed successfully.
+     *
+     *   - `Error` - If the query failed. The response will contain a `code` and a `message` in this case.
+     *
+     *
+     *
+     */
+    post(options: SearchGetGeocodingBatchParameters): StreamableMethod<SearchGetGeocodingBatch200Response | SearchGetGeocodingBatchDefaultResponse>;
+}
+export interface GetPolygon {
+    /**
+     *
+     * The `Get Polygon` API is an HTTP `GET` request that supplies polygon data of a geographical area outline such as a city or a country region.
+     */
+    get(options: SearchGetPolygonParameters): StreamableMethod<SearchGetPolygon200Response | SearchGetPolygonDefaultResponse>;
+}
+export interface GetReverseGeocoding {
+    /**
+     *
+     * The `Get Reverse Geocoding` API is an HTTP `GET` request used to translate a coordinate (example: 37.786505, -122.3862) into a human understandable street address. Useful in tracking applications where you receive a GPS feed from the device or asset and wish to know the address associated with the coordinates. This endpoint will return address information for a given coordinate.
+     */
+    get(options: SearchGetReverseGeocodingParameters): StreamableMethod<SearchGetReverseGeocoding200Response | SearchGetReverseGeocodingDefaultResponse>;
+}
+export interface GetReverseGeocodingBatch {
+    /**
+     *
+     * The `Get Reverse Geocoding Batch` API is an HTTP `POST` request that sends batches of up to **100** queries to [Reverse Geocoding](/rest/api/maps/search/get-reverse-geocoding) API using a single request.
+     *
+     * ### Submit Synchronous Batch Request
+     * The Synchronous API is recommended for lightweight batch requests. When the service receives a request, it will respond as soon as the batch items are calculated and there will be no possibility to retrieve the results later. The Synchronous API will return a timeout error (a 408 response) if the request takes longer than 60 seconds. The number of batch items is limited to **100** for this API.
+     * ```
+     * POST https://atlas.microsoft.com/reverseGeocode:batch?api-version=2023-06-01
+     * ```
+     * ### POST Body for Batch Request
+     * To send the _reverse geocoding_ queries you will use a `POST` request where the request body will contain the `batchItems` array in `json` format and the `Content-Type` header will be set to `application/json`. Here's a sample request body containing 2 _reverse geocoding_ queries:
+     *
+     *
+     * ```
+     * {
+     *   "batchItems": [
+     *     {
+     *       "coordinates": [-122.128275, 47.639429],
+     *       "resultTypes": ["Address", "PopulatedPlace"]
+     *     },
+     *     {
+     *       "coordinates": [-122.341979399674, 47.6095253501216]
+     *     }
+     *   ]
+     * }
+     * ```
+     *
+     * A _reverse geocoding_ batchItem object can accept any of the supported _reverse geocoding_ [URI parameters](/rest/api/maps/search/get-reverse-geocoding#uri-parameters).
+     *
+     *
+     * The batch should contain at least **1** query.
+     *
+     *
+     * ### Batch Response Model
+     * The batch response contains a `summary` component that indicates the `totalRequests` that were part of the original batch request and `successfulRequests` i.e. queries which were executed successfully. The batch response also includes a `batchItems` array which contains a response for each and every query in the batch request. The `batchItems` will contain the results in the exact same order the original queries were sent in the batch request. Each item is of one of the following types:
+     *
+     *   - [`GeocodingResponse`](/rest/api/maps/search/get-reverse-geocoding#geocodingresponse) - If the query completed successfully.
+     *
+     *   - `Error` - If the query failed. The response will contain a `code` and a `message` in this case.
+     *
+     *
+     *
+     */
+    post(options: SearchGetReverseGeocodingBatchParameters): StreamableMethod<SearchGetReverseGeocodingBatch200Response | SearchGetReverseGeocodingBatchDefaultResponse>;
+}
+export interface Routes {
+    /** Resource for '/geocode' has methods for the following verbs: get */
+    (path: "/geocode"): GetGeocoding;
+    /** Resource for '/geocode:batch' has methods for the following verbs: post */
+    (path: "/geocode:batch"): GetGeocodingBatch;
+    /** Resource for '/search/polygon' has methods for the following verbs: get */
+    (path: "/search/polygon"): GetPolygon;
+    /** Resource for '/reverseGeocode' has methods for the following verbs: get */
+    (path: "/reverseGeocode"): GetReverseGeocoding;
+    /** Resource for '/reverseGeocode:batch' has methods for the following verbs: post */
+    (path: "/reverseGeocode:batch"): GetReverseGeocodingBatch;
+}
+export type MapsSearchClient = Client & {
+    path: Routes;
+};
+//# sourceMappingURL=clientDefinitions.d.ts.map

package/dist/react-native/generated/clientDefinitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clientDefinitions.d.ts","sourceRoot":"","sources":["../../../src/generated/clientDefinitions.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,4BAA4B,EAC5B,iCAAiC,EACjC,0BAA0B,EAC1B,mCAAmC,EACnC,wCAAwC,EACzC,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,6BAA6B,EAC7B,iCAAiC,EACjC,kCAAkC,EAClC,sCAAsC,EACtC,2BAA2B,EAC3B,+BAA+B,EAC/B,oCAAoC,EACpC,wCAAwC,EACxC,yCAAyC,EACzC,6CAA6C,EAC9C,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEnE,MAAM,WAAW,YAAY;IAC3B;;;;;OAKG;IACH,GAAG,CACD,OAAO,CAAC,EAAE,4BAA4B,GACrC,gBAAgB,CACjB,6BAA6B,GAAG,iCAAiC,CAClE,CAAC;CACH;AAED,MAAM,WAAW,iBAAiB;IAChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6CG;IACH,IAAI,CACF,OAAO,EAAE,iCAAiC,GACzC,gBAAgB,CACjB,kCAAkC,GAAG,sCAAsC,CAC5E,CAAC;CACH;AAED,MAAM,WAAW,UAAU;IACzB;;;OAGG;IACH,GAAG,CACD,OAAO,EAAE,0BAA0B,GAClC,gBAAgB,CACjB,2BAA2B,GAAG,+BAA+B,CAC9D,CAAC;CACH;AAED,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,GAAG,CACD,OAAO,EAAE,mCAAmC,GAC3C,gBAAgB,CACf,oCAAoC,GACpC,wCAAwC,CAC3C,CAAC;CACH;AAED,MAAM,WAAW,wBAAwB;IACvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;IACH,IAAI,CACF,OAAO,EAAE,wCAAwC,GAChD,gBAAgB,CACf,yCAAyC,GACzC,6CAA6C,CAChD,CAAC;CACH;AAED,MAAM,WAAW,MAAM;IACrB,uEAAuE;IACvE,CAAC,IAAI,EAAE,UAAU,GAAG,YAAY,CAAC;IACjC,8EAA8E;IAC9E,CAAC,IAAI,EAAE,gBAAgB,GAAG,iBAAiB,CAAC;IAC5C,8EAA8E;IAC9E,CAAC,IAAI,EAAE,iBAAiB,GAAG,UAAU,CAAC;IACtC,8EAA8E;IAC9E,CAAC,IAAI,EAAE,iBAAiB,GAAG,mBAAmB,CAAC;IAC/C,qFAAqF;IACrF,CAAC,IAAI,EAAE,uBAAuB,GAAG,wBAAwB,CAAC;CAC3D;AAED,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG;IACtC,IAAI,EAAE,MAAM,CAAC;CACd,CAAC"}

package/dist/react-native/generated/clientDefinitions.js

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+export {};
+//# sourceMappingURL=clientDefinitions.js.map