@azure-rest/maps-search 2.0.0-beta.2 → 2.0.0-beta.4

package/CHANGELOG.md

@@ -0,0 +1,59 @@
+# Release History
+
+## 2.0.0-beta.4 (Unreleased)
+
+### Features Added
+
+### Breaking Changes
+
+### Bugs Fixed
+
+### Other Changes
+
+## 2.0.0-beta.3 (2025-03-14)
+
+### Bugs Fixed
+
+- Fix ESM module file not found.
+
+## 2.0.0-beta.2 (2024-12-10)
+
+### Breaking Changes
+
+- Marked fields in various interfaces as readonly, which may impact code that previously modified these properties.
+
+### Bugs Fixed
+
+- Fix the Microsoft Entra ID authentication when providing `baseUrl`.
+
+## 2.0.0-beta.1 (2024-01-09)
+
+### Features Added
+
+- Introducing compliant [Maps Search V2](https://learn.microsoft.com/rest/api/maps/search?view=rest-maps-2023-06-01) features:
+  - `/geocode`, `/geocode:batch`: Turn an address to coordinates. Replace the v1 `/search/address`, `/search/address/batch/sync/`.
+  - `/reverseGeocode`, `/reverseGeocode:batch`: Turn coordinates to an address. Replace the v1 `/search/address/reverse`, `/search/address/batch/reverse/sync/`.
+  - `/search/polygon`: Supplies polygon data of a geographical area outline such as a city or a country region. Replace the v1 `/search/polygon`.
+- Support SAS token authentication.
+
+### Breaking Changes
+
+- All the paths in V1 are now deprecated. Please follow the section "Use V1 SDK" in README if you find paths in V1 are still needed.
+
+## 1.0.0-beta.3 (2023-07-11)
+
+### Other Changes
+
+- Update README.
+
+## 1.0.0-beta.2 (2023-02-07)
+
+### Bugs Fixed
+
+- Correct the path of the type declaration file.
+
+## 1.0.0-beta.1 (2023-01-10)
+
+### Features Added
+
+- Initial Release

package/LICENSE

@@ -1,6 +1,6 @@
-The MIT License (MIT)
+Copyright (c) Microsoft Corporation.
 
-Copyright (c) 2022 Microsoft
+MIT License
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -12,10 +12,10 @@ furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

package/README.md

@@ -8,9 +8,9 @@ Key links:
 
 - [Source code](https://github.com/Azure/azure-sdk-for-js/tree/main/sdk/maps/maps-search-rest)
 - [Package (NPM)](https://www.npmjs.com/package/@azure-rest/maps-search)
-- [API reference documentation](https://docs.microsoft.com/javascript/api/@azure-rest/maps-search?view=azure-node-preview)
+- [API reference documentation](https://learn.microsoft.com/javascript/api/@azure-rest/maps-search?view=azure-node-preview)
 - [Samples](https://github.com/Azure/azure-sdk-for-js/tree/main/sdk/maps/maps-search-rest/samples)
-- [Product Information](https://docs.microsoft.com/rest/api/maps/search)
+- [Product Information](https://learn.microsoft.com/rest/api/maps/search)
 
 | Package Version | Service Version |
 | --------------- | --------------- |
@@ -27,9 +27,9 @@ Key links:
 ### Prerequisites
 
 - You must have an [Azure subscription](https://azure.microsoft.com/free/) to use this package.
-- An [Azure Maps account](https://docs.microsoft.com/azure/azure-maps/how-to-manage-account-keys). You can create the resource via the [Azure Portal](https://portal.azure.com), the [Azure PowerShell](https://docs.microsoft.com/powershell/module/az.maps/new-azmapsaccount), or the [Azure CLI](https://docs.microsoft.com/cli/azure).
+- An [Azure Maps account](https://learn.microsoft.com/azure/azure-maps/how-to-manage-account-keys). You can create the resource via the [Azure Portal](https://portal.azure.com), the [Azure PowerShell](https://learn.microsoft.com/powershell/module/az.maps/new-azmapsaccount), or the [Azure CLI](https://learn.microsoft.com/cli/azure).
 
-If you use Azure CLI, replace `<resource-group-name>` and `<map-account-name>` of your choice, and select a proper [pricing tier](https://docs.microsoft.com/azure/azure-maps/choose-pricing-tier) based on your needs via the `<sku-name>` parameter. Please refer to [this page](https://docs.microsoft.com/cli/azure/maps/account?view=azure-cli-latest#az_maps_account_create) for more details.
+If you use Azure CLI, replace `<resource-group-name>` and `<map-account-name>` of your choice, and select a proper [pricing tier](https://learn.microsoft.com/azure/azure-maps/choose-pricing-tier) based on your needs via the `<sku-name>` parameter. Please refer to [this page](https://learn.microsoft.com/cli/azure/maps/account?view=azure-cli-latest#az_maps_account_create) for more details.
 
 ```bash
 az maps account create --resource-group <resource-group-name> --name <map-account-name> --sku <sku-name>
@@ -55,16 +55,16 @@ You can authenticate with Microsoft Entra ID using the [Azure Identity library](
 npm install @azure/identity
 ```
 
-You will also need to register a new Microsoft Entra ID application and grant access to Azure Maps by assigning the suitable role to your service principal. Please refer to the [Manage authentication](https://docs.microsoft.com/azure/azure-maps/how-to-manage-authentication) page.
+You will also need to register a new Microsoft Entra ID application and grant access to Azure Maps by assigning the suitable role to your service principal. Please refer to the [Manage authentication](https://learn.microsoft.com/azure/azure-maps/how-to-manage-authentication) page.
 
 Set the values of the client ID, tenant ID, and client secret of the Microsoft Entra ID application as environment variables: `AZURE_CLIENT_ID`, `AZURE_TENANT_ID`, `AZURE_CLIENT_SECRET`.
 
 You will also need to specify the Azure Maps resource you intend to use by specifying the `clientId` in the client options.
-The Azure Maps resource client id can be found in the Authentication sections in the Azure Maps resource. Please refer to the [documentation](https://docs.microsoft.com/azure/azure-maps/how-to-manage-authentication#view-authentication-details) on how to find it.
+The Azure Maps resource client id can be found in the Authentication sections in the Azure Maps resource. Please refer to the [documentation](https://learn.microsoft.com/azure/azure-maps/how-to-manage-authentication#view-authentication-details) on how to find it.
 
-```javascript
-const MapsSearch = require("@azure-rest/maps-search").default;
-const { DefaultAzureCredential } = require("@azure/identity");
+```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>");
@@ -74,9 +74,9 @@ const client = MapsSearch(credential, "<maps-account-client-id>");
 
 You can authenticate with your Azure Maps Subscription Key.
 
-```javascript
-const MapsSearch = require("@azure-rest/maps-search").default;
-const { AzureKeyCredential } = require("@azure/core-auth");
+```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);
@@ -98,11 +98,11 @@ npm install @azure/core-auth
 
 Finally, you can use the SAS token to authenticate the client:
 
-```javascript
-const MapsSearch = require("@azure-rest/maps-search").default;
-const { AzureSASCredential } = require("@azure/core-auth");
-const { DefaultAzureCredential } = require("@azure/identity");
-const { AzureMapsManagementClient } = require("@azure/arm-maps");
+```ts snippet:ReadmeSampleCreateClient_SAS
+import { DefaultAzureCredential } from "@azure/identity";
+import { AzureMapsManagementClient } from "@azure/arm-maps";
+import { AzureSASCredential } from "@azure/core-auth";
+import MapsSearch from "@azure-rest/maps-search";
 
 const subscriptionId = "<subscription ID of the map account>";
 const resourceGroupName = "<resource group name of the map account>";
@@ -114,6 +114,7 @@ const mapsAccountSasParameters = {
   principalId: "<principle ID (object ID) of the managed identity>",
   signingKey: "primaryKey",
 };
+
 const credential = new DefaultAzureCredential();
 const managementClient = new AzureMapsManagementClient(credential, subscriptionId);
 const { accountSasToken } = await managementClient.accounts.listSas(
@@ -121,9 +122,11 @@ const { accountSasToken } = await managementClient.accounts.listSas(
   accountName,
   mapsAccountSasParameters,
 );
+
 if (accountSasToken === undefined) {
   throw new Error("No accountSasToken was found for the Maps Account.");
 }
+
 const sasCredential = new AzureSASCredential(accountSasToken);
 const client = MapsSearch(sasCredential);
 ```
@@ -145,41 +148,36 @@ The following sections provide several code snippets covering some of the most c
 
 You can use an authenticated client to convert an address into latitude and longitude coordinates. This process is also called geocoding. In addition to returning the coordinates, the response will also return detailed address properties such as postal code, admin districts, and country/region information.
 
-```javascript
-const MapsSearch = require("@azure-rest/maps-search").default;
-const { AzureKeyCredential } = require("@azure/core-auth");
-const { isUnexpected } = require("@azure-rest/maps-search");
+```ts snippet:ReadmeSampleGeocode
+import { DefaultAzureCredential } from "@azure/identity";
+import MapsSearch, { isUnexpected } from "@azure-rest/maps-search";
 
-/** Initialize the MapsSearchClient */
-const client = MapsSearch(new AzureKeyCredential("<subscription-key>"));
+const credential = new DefaultAzureCredential();
+const client = MapsSearch(credential, "<maps-account-client-id>");
 
-async function main() {
-  /** Make a request to the geocoding API */
-  const response = await client
-    .path("/geocode")
-    .get({ queryParameters: { query: "400 Broad, Seattle" } });
-  /** Handle error response */
-  if (isUnexpected(response)) {
-    throw response.body.error;
-  }
-  /** Log the response body. */
-  if (!response.body.features) {
-    console.log(`No coordinates found for the address.`);
-  } else {
-    console.log(`The followings are the possible coordinates of the address:`);
-    for (const result of response.body.features) {
-      const [lon, lat] = result.geometry.coordinates;
-      console.log(`Latitude: ${lat}, Longitude ${lon}`);
-      console.log("Postal code: ", result.properties?.address?.postalCode);
-      console.log("Admin districts: ", result.properties?.address?.adminDistricts?.join(", "));
-      console.log("Country region: ", result.properties?.address?.countryRegion);
-    }
-  }
+/** Make a request to the geocoding API */
+const response = await client
+  .path("/geocode")
+  .get({ queryParameters: { query: "400 Broad, Seattle" } });
+// @ts-preserve-whitespaces
+/** Handle error response */
+if (isUnexpected(response)) {
+  throw response.body.error;
 }
 
-main().catch((err) => {
-  console.log(err);
-});
+/** Log the response body. */
+if (!response.body.features) {
+  console.log(`No coordinates found for the address.`);
+} else {
+  console.log(`The followings are the possible coordinates of the address:`);
+  for (const result of response.body.features) {
+    const [lon, lat] = result.geometry.coordinates;
+    console.log(`Latitude: ${lat}, Longitude ${lon}`);
+    console.log("Postal code: ", result.properties?.address?.postalCode);
+    console.log("Admin districts: ", result.properties?.address?.adminDistricts?.join(", "));
+    console.log("Country region: ", result.properties?.address?.countryRegion);
+  }
+}
 ```
 
 ### Make a Reverse Address Search to translate coordinate location to street address
@@ -187,40 +185,35 @@ main().catch((err) => {
 You can translate coordinates into human readable street addresses. This process is also called reverse geocoding.
 This is often used for applications that consume GPS feeds and want to discover addresses at specific coordinate points.
 
-```javascript
-const MapsSearch = require("@azure-rest/maps-search").default;
-const { AzureKeyCredential } = require("@azure/core-auth");
-const { isUnexpected } = require("@azure-rest/maps-search");
+```ts snippet:ReadmeSampleReverseGeocode
+import { DefaultAzureCredential } from "@azure/identity";
+import MapsSearch, { isUnexpected } from "@azure-rest/maps-search";
 
-/** Initialize the MapsSearchClient */
-const client = MapsSearch(new AzureKeyCredential("<subscription-key>"));
+const credential = new DefaultAzureCredential();
+const client = MapsSearch(credential, "<maps-account-client-id>");
 
-async function main() {
-  /** Make the request. */
-  const response = await client.path("/reverseGeocode").get({
-    queryParameters: { coordinates: [-121.89, 37.337] }, // [longitude, latitude],
-  });
-  /** Handle error response. */
-  if (isUnexpected(response)) {
-    throw response.body.error;
-  }
-  if (!response.body.features || response.body.features.length === 0) {
-    console.log("No results found.");
-  } else {
-    /** Log the response body. */
-    for (const feature of response.body.features) {
-      if (feature.properties?.address?.formattedAddress) {
-        console.log(feature.properties.address.formattedAddress);
-      } else {
-        console.log("No address found.");
-      }
+/** Make the request. */
+const response = await client.path("/reverseGeocode").get({
+  queryParameters: { coordinates: [-121.89, 37.337] }, // [longitude, latitude],
+});
+
+/** Handle error response. */
+if (isUnexpected(response)) {
+  throw response.body.error;
+}
+
+if (!response.body.features || response.body.features.length === 0) {
+  console.log("No results found.");
+} else {
+  /** Log the response body. */
+  for (const feature of response.body.features) {
+    if (feature.properties?.address?.formattedAddress) {
+      console.log(feature.properties.address.formattedAddress);
+    } else {
+      console.log("No address found.");
     }
   }
 }
-
-main().catch((err) => {
-  console.log(err);
-});
 ```
 
 ## Use V1 SDK
@@ -234,19 +227,17 @@ npm install @azure-rest/map-search-v2@npm:@azure-rest/map-search@^2.0.0
 
 Then, you can import the two packages:
 
-```javascript
-const MapsSearchV1 = require("@azure-rest/map-search-v1").default;
-const MapsSearchV2 = require("@azure-rest/map-search-v2").default;
+```ts snippet:ignore
+import MapsSearchV1 from "@azure-rest/map-search-v1";
+import MapsSearchV2 from "@azure-rest/map-search-v2";
 ```
 
 In the following example, we want to accept an address and search POIs around it. We'll use V2 SDK to get the coordinate of the address(/geocode), and use V1 SDK to search POIs around it(/search/nearby).
 
-```javascript
-const MapsSearchV1 = require("@azure-rest/map-search-v1").default;
-const MapsSearchV2 = require("@azure-rest/map-search-v2").default;
-const { AzureKeyCredential } = require("@azure/core-auth");
-const { isUnexpected: isUnexpectedV1 } = require("@azure-rest/maps-search-v1");
-const { isUnexpected: isUnexpectedV2 } = require("@azure-rest/maps-search-v2");
+```ts snippet:ignore
+import MapsSearchV1, { isUnexpected: isUnexpectedV1 } from "@azure-rest/map-search-v1";
+import MapsSearchV2, { isUnexpected: isUnexpectedV2 } from "@azure-rest/map-search-v2";
+import { AzureKeyCredential } from "@azure/core-auth";
 
 /** Initialize the MapsSearchClient */
 const clientV1 = MapsSearchV1(new AzureKeyCredential("<subscription-key>"));
@@ -257,6 +248,7 @@ async function searchNearby(address) {
   const geocodeResponse = await clientV2
     .path("/geocode")
     .get({ queryParameters: { query: address } });
+
   /** Handle error response */
   if (isUnexpectedV2(geocodeResponse)) {
     throw geocodeResponse.body.error;
@@ -297,12 +289,10 @@ main().catch((err) => {
 
 Enabling logging may help uncover useful information about failures. In order to see a log of HTTP requests and responses, set the `AZURE_LOG_LEVEL` environment variable to `info`. Alternatively, logging can be enabled at runtime by calling `setLogLevel` in the `@azure/logger`:
 
-```javascript
-const { setLogLevel } = require("@azure/logger");
+```ts snippet:SetLogLevel
+import { setLogLevel } from "@azure/logger";
 
 setLogLevel("info");
 ```
 
 For more detailed instructions on how to enable logs, you can look at the [@azure/logger package docs](https://github.com/Azure/azure-sdk-for-js/tree/main/sdk/core/logger).
-
-![Impressions](https://azure-sdk-impressions.azurewebsites.net/api/impressions/azure-sdk-for-js%2Fsdk%2Fmaps%2Fmap-search-rest%2FREADME.png)

package/dist/browser/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/browser/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-esm/src → dist/browser}/MapsSearch.js

@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 import { isSASCredential, isTokenCredential } from "@azure/core-auth";
 import { createMapsClientIdPolicy } from "@azure/maps-common";
-import createClient from "../generated";
+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;

package/dist/browser/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/browser/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/browser/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/browser/generated/clientDefinitions.js

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

package/dist/browser/generated/clientDefinitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clientDefinitions.js","sourceRoot":"","sources":["../../../src/generated/clientDefinitions.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport {\n  SearchGetGeocodingParameters,\n  SearchGetGeocodingBatchParameters,\n  SearchGetPolygonParameters,\n  SearchGetReverseGeocodingParameters,\n  SearchGetReverseGeocodingBatchParameters,\n} from \"./parameters.js\";\nimport {\n  SearchGetGeocoding200Response,\n  SearchGetGeocodingDefaultResponse,\n  SearchGetGeocodingBatch200Response,\n  SearchGetGeocodingBatchDefaultResponse,\n  SearchGetPolygon200Response,\n  SearchGetPolygonDefaultResponse,\n  SearchGetReverseGeocoding200Response,\n  SearchGetReverseGeocodingDefaultResponse,\n  SearchGetReverseGeocodingBatch200Response,\n  SearchGetReverseGeocodingBatchDefaultResponse,\n} from \"./responses.js\";\nimport { Client, StreamableMethod } from \"@azure-rest/core-client\";\n\nexport interface GetGeocoding {\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   */\n  get(\n    options?: SearchGetGeocodingParameters,\n  ): StreamableMethod<\n    SearchGetGeocoding200Response | SearchGetGeocodingDefaultResponse\n  >;\n}\n\nexport interface GetGeocodingBatch {\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   */\n  post(\n    options: SearchGetGeocodingBatchParameters,\n  ): StreamableMethod<\n    SearchGetGeocodingBatch200Response | SearchGetGeocodingBatchDefaultResponse\n  >;\n}\n\nexport interface GetPolygon {\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   */\n  get(\n    options: SearchGetPolygonParameters,\n  ): StreamableMethod<\n    SearchGetPolygon200Response | SearchGetPolygonDefaultResponse\n  >;\n}\n\nexport interface GetReverseGeocoding {\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   */\n  get(\n    options: SearchGetReverseGeocodingParameters,\n  ): StreamableMethod<\n    | SearchGetReverseGeocoding200Response\n    | SearchGetReverseGeocodingDefaultResponse\n  >;\n}\n\nexport interface GetReverseGeocodingBatch {\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   */\n  post(\n    options: SearchGetReverseGeocodingBatchParameters,\n  ): StreamableMethod<\n    | SearchGetReverseGeocodingBatch200Response\n    | SearchGetReverseGeocodingBatchDefaultResponse\n  >;\n}\n\nexport interface Routes {\n  /** Resource for '/geocode' has methods for the following verbs: get */\n  (path: \"/geocode\"): GetGeocoding;\n  /** Resource for '/geocode:batch' has methods for the following verbs: post */\n  (path: \"/geocode:batch\"): GetGeocodingBatch;\n  /** Resource for '/search/polygon' has methods for the following verbs: get */\n  (path: \"/search/polygon\"): GetPolygon;\n  /** Resource for '/reverseGeocode' has methods for the following verbs: get */\n  (path: \"/reverseGeocode\"): GetReverseGeocoding;\n  /** Resource for '/reverseGeocode:batch' has methods for the following verbs: post */\n  (path: \"/reverseGeocode:batch\"): GetReverseGeocodingBatch;\n}\n\nexport type MapsSearchClient = Client & {\n  path: Routes;\n};\n"]}

package/dist/browser/generated/index.d.ts

@@ -0,0 +1,10 @@
+import MapsSearchClient from "./mapsSearchClient.js";
+export * from "./mapsSearchClient.js";
+export * from "./parameters.js";
+export * from "./responses.js";
+export * from "./clientDefinitions.js";
+export * from "./isUnexpected.js";
+export * from "./models.js";
+export * from "./outputModels.js";
+export default MapsSearchClient;
+//# sourceMappingURL=index.d.ts.map

package/dist/browser/generated/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/generated/index.ts"],"names":[],"mappings":"AAGA,OAAO,gBAAgB,MAAM,uBAAuB,CAAC;AAErD,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAElC,eAAe,gBAAgB,CAAC"}