@azure-rest/maps-route 1.0.0-beta.2 → 1.0.0-beta.4

package/types/maps-route-rest.d.ts

@@ -1,15 +1,17 @@
-import { AzureKeyCredential } from '@azure/core-auth';
+import { AbortSignalLike } from '@azure/abort-controller';
+import type { AzureKeyCredential } from '@azure/core-auth';
+import type { AzureSASCredential } from '@azure/core-auth';
+import { CancelOnProgress } from '@azure/core-lro';
 import { Client } from '@azure-rest/core-client';
 import { ClientOptions } from '@azure-rest/core-client';
+import { CreateHttpPollerOptions } from '@azure/core-lro';
 import { HttpResponse } from '@azure-rest/core-client';
-import { LatLon } from '@azure/maps-common';
-import { LroEngineOptions } from '@azure/core-lro';
-import { PollerLike } from '@azure/core-lro';
-import { PollOperationState } from '@azure/core-lro';
+import type { LatLon } from '@azure/maps-common';
+import { OperationState } from '@azure/core-lro';
 import { RawHttpHeaders } from '@azure/core-rest-pipeline';
 import { RequestParameters } from '@azure-rest/core-client';
 import { StreamableMethod } from '@azure-rest/core-client';
-import { TokenCredential } from '@azure/core-auth';
+import type { TokenCredential } from '@azure/core-auth';
 
 /** This type represents the request body for the Batch service. */
 export declare interface BatchRequest {
@@ -26,23 +28,25 @@ export declare interface BatchRequestItem {
 /** An item returned from Batch API. Extend with 'response' property. */
 export declare interface BatchResultItemOutput {
     /** HTTP request status code. */
-    statusCode: number;
+    readonly statusCode: number;
 }
 
 /** This object is returned from a successful Batch service call. Extend with 'batchItems' property. */
 export declare interface BatchResultOutput {
     /** Summary of the results for the batch request */
-    summary: BatchResultSummaryOutput;
+    readonly summary: BatchResultSummaryOutput;
 }
 
 /** Summary of the results for the batch request */
 export declare interface BatchResultSummaryOutput {
     /** Number of successful requests in the batch */
-    successfulRequests: number;
+    readonly successfulRequests: number;
     /** Total number of requests in the batch */
-    totalRequests: number;
+    readonly totalRequests: number;
 }
 
+export declare function buildMultiCollection(items: string[], parameterName: string): string;
+
 /**
  * Create a batch request body of a bunch of route direction requests.
  *
@@ -54,17 +58,17 @@ export declare function createRouteDirectionsBatchRequest(queryParamProperties:
 /** Effective parameter or data used when calling this Route API. */
 export declare interface EffectiveSettingOutput {
     /** Name of the parameter used. */
-    key: string;
+    readonly key: string;
     /** Value of the parameter used. */
-    value: string;
+    readonly value: string;
 }
 
 /** The error detail. */
 export declare interface ErrorDetailOutput {
     /** The error code. */
-    code?: string;
+    readonly code?: string;
     /** The error message. */
-    message?: string;
+    readonly message?: string;
 }
 
 /** Common error response for all Azure Resource Manager APIs to return error details for failed operations. (This also follows the OData error response format.). */
@@ -194,25 +198,21 @@ export declare interface GeoJsonPolygonData {
  * @param options - Options to set a resume state or custom polling interval.
  * @returns - A poller object to poll for operation state updates and eventually get the final response.
  */
-export declare function getLongRunningPoller<TResult extends HttpResponse>(client: Client, initialResponse: TResult, options?: LroEngineOptions<TResult, PollOperationState<TResult>>): PollerLike<PollOperationState<TResult>, TResult>;
+export declare function getLongRunningPoller<TResult extends HttpResponse>(client: Client, initialResponse: TResult, options?: CreateHttpPollerOptions<TResult, OperationState<TResult>>): Promise<SimplePollerLike<OperationState<TResult>, TResult>>;
 
 export declare interface GetRouteDirections {
     /**
-     * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
-     *
      *
-     * Returns  a route between an origin and a destination, passing through waypoints if they are specified. The route will take into account factors such as current traffic and the typical road speeds on the requested day of the week and time of day.
+     * The `Get Route Directions` API is an HTTP `GET` request that returns a route between an origin and a destination, passing through waypoints if specified. The route takes into account factors such as current traffic and the typical road speeds on the requested day of the week and time of day.
      *
      * Information returned includes the distance, estimated travel time, and a representation of the route geometry. Additional routing information such as optimized waypoint order or turn by turn instructions is also available, depending on the options selected.
      *
-     * Routing service provides a set of parameters for a detailed description of vehicle-specific Consumption Model. Please check [Consumption Model](https://docs.microsoft.com/azure/azure-maps/consumption-model) for detailed explanation of the concepts and parameters involved.
+     * Routing service provides a set of parameters for a detailed description of a vehicle-specific consumption model. For more information, see [Consumption Model](/azure/azure-maps/consumption-model).
      */
     get(options: RouteGetRouteDirectionsParameters): StreamableMethod<RouteGetRouteDirections200Response | RouteGetRouteDirectionsDefaultResponse>;
     /**
-     * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
-     *
      *
-     * Returns  a route between an origin and a destination, passing through waypoints if they are specified. The route will take into account factors such as current traffic and the typical road speeds on the requested day of the week and time of day.
+     * The `Post Route Directions` API is an HTTP `POST` request that returns a route between an origin and a destination, passing through waypoints if they are specified. The route will take into account factors such as current traffic and the typical road speeds on the requested day of the week and time of day.
      *
      * Information returned includes the distance, estimated travel time, and a representation of the route geometry. Additional routing information such as optimized waypoint order or turn by turn instructions is also available, depending on the options selected.
      *
@@ -223,14 +223,10 @@ export declare interface GetRouteDirections {
 
 export declare interface GetRouteRange {
     /**
-     * __Route Range (Isochrone) API__
-     *
-     *
-     * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
      *
-     * This service will calculate a set of locations that can be reached from the origin point based on fuel, energy,  time or distance budget that is specified. A polygon boundary (or Isochrone) is returned in a counterclockwise  orientation as well as the precise polygon center which was the result of the origin point.
+     * The `Get Route Range` (Isochrone) API is an HTTP `GET` request that will calculate a set of locations that can be reached from the origin point based on fuel, energy, time or distance budget that is specified. A polygon boundary (or Isochrone) is returned in a counterclockwise  orientation as well as the precise polygon center which was the result of the origin point.
      *
-     * The returned polygon can be used for further processing such as  [Search Inside Geometry](https://docs.microsoft.com/rest/api/maps/search/postsearchinsidegeometry) to  search for POIs within the provided Isochrone.
+     * The returned polygon can be used for further processing such as  [Search Inside Geometry](/rest/api/maps/search/post-search-inside-geometry) to  search for POIs within the provided isochrone.
      */
     get(options: RouteGetRouteRangeParameters): StreamableMethod<RouteGetRouteRange200Response | RouteGetRouteRangeDefaultResponse>;
 }
@@ -275,7 +271,7 @@ declare function MapsRoute(credential: AzureKeyCredential, options?: ClientOptio
  *
  * @example
  * ```ts
- * import MapsRoute from "@azure/maps-route";
+ * import MapsRoute from "@azure-rest/maps-route";
  * import { DefaultAzureCredential } from "@azure/identity";
  *
  * const credential = new DefaultAzureCredential();
@@ -287,22 +283,40 @@ declare function MapsRoute(credential: AzureKeyCredential, options?: ClientOptio
  * @param options - Options used to configure the Route Client
  */
 declare function MapsRoute(credential: TokenCredential, mapsAccountClientId: string, options?: ClientOptions): MapsRouteClient;
+
+/**
+ * Creates an instance of MapsRoute from an Azure Identity `AzureSASCredential`.
+ *
+ * @example
+ * ```ts
+ * import MapsRoute from "@azure-rest/maps-route";
+ * import { AzureSASCredential } from "@azure/core-auth";
+ *
+ * const credential = new AzureSASCredential("<SAS Token>");
+ * const client = MapsRoute(credential);
+ * ```
+ *
+ * @param credential - An AzureSASCredential instance used to authenticate requests to the service
+ * @param options - Options used to configure the Route Client
+ */
+declare function MapsRoute(credential: AzureSASCredential, options?: ClientOptions): MapsRouteClient;
 export default MapsRoute;
 
 export declare type MapsRouteClient = Client & {
     path: Routes;
 };
 
+/** The optional parameters for the client */
+export declare interface MapsRouteClientOptions extends ClientOptions {
+    /** The api version option of the client */
+    apiVersion?: string;
+}
+
 export declare interface RequestRouteDirectionsBatch {
     /**
-     * **Route Directions Batch API**
-     *
-     *
-     * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
      *
+     * The `Post Route Directions Batch` API is an HTTP `POST` request that sends batches of queries to the [Get Route Directions](/rest/api/maps/route/get-route-directions) API using a single asynchronous request. You can call `Route Directions Batch` API to run either asynchronously (async) or synchronously (sync). The async API allows caller to batch up to **700** queries and sync API up to **100** queries. To call the `Post Route Directions Batch` API in a synchronous request, see [Post Route Directions Batch Sync](/rest/api/maps/route/post-route-directions-batch-sync).
      *
-     *
-     * The Route Directions Batch API sends batches of queries to [Route Directions API](https://docs.microsoft.com/rest/api/maps/route/getroutedirections) using just a single API call. You can call Route Directions Batch API to run either asynchronously (async) or synchronously (sync). The async API allows caller to batch up to **700** queries and sync API up to **100** queries.
      * ### Submit Asynchronous Batch Request
      * The Asynchronous API is appropriate for processing big volumes of relatively complex route requests
      * - It allows the retrieval of results in a separate call (multiple downloads are possible).
@@ -310,10 +324,13 @@ export declare interface RequestRouteDirectionsBatch {
      * - The number of batch items is limited to **700** for this API.
      *
      * When you make a request by using async request, by default the service returns a 202 response code along a redirect URL in the Location field of the response header. This URL should be checked periodically until the response data or error information is available.
-     * The asynchronous responses are stored for **14** days. The redirect URL returns a 404 response if used after the expiration period.
+     * The asynchronous responses are stored for **24** hours. The redirect URL returns a 404 response if used after the expiration period.
      *
-     * Please note that asynchronous batch request is a long-running request. Here's a typical sequence of operations:
-     * 1. Client sends a Route Directions Batch `POST` request to Azure Maps
+     * Please note that asynchronous batch request is a long-running operation. Here's a typical sequence of operations:
+     * 1. Client sends a Route Directions Batch `POST` request to Azure Maps.
+     * ```
+     * POST https://atlas.microsoft.com/route/directions/batch/json?api-version=1.0&subscription-key={subscription-key}
+     * ```
      * 2. The server will respond with one of the following:
      *
      *     > HTTP `202 Accepted` - Batch request has been accepted.
@@ -322,9 +339,9 @@ export declare interface RequestRouteDirectionsBatch {
      *
      * 3. If the batch request was accepted successfully, the `Location` header in the response contains the URL to download the results of the batch request.
      *     This status URI looks like following:
-     *
-     * ``` GET https://atlas.microsoft.com/route/directions/batch/{batch-id}?api-version=1.0 ```
-     * Note:- Please remember to add AUTH information (subscription-key/azure_auth - See [Security](#security)) to the _status URI_ before running it. <br>
+     * ```
+     * GET https://atlas.microsoft.com/route/directions/batch/{batch-id}?api-version=1.0&subscription-key={subscription-key}
+     * ```
      * 4. Client issues a `GET` request on the _download URL_ obtained in Step 3 to download the batch results.
      *
      * ### POST Body for Batch Request
@@ -447,7 +464,8 @@ export declare interface RequestRouteDirectionsBatch {
      */
     post(options: RouteRequestRouteDirectionsBatchParameters): StreamableMethod<RouteRequestRouteDirectionsBatch200Response | RouteRequestRouteDirectionsBatch202Response>;
     /**
-     * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
+     *
+     * The `Get Route Directions Batch` API is an HTTP `GET` request that sends batches of queries to the [Get Route Directions](/rest/api/maps/route/get-route-directions) API using a single request. You can call `Get Route Directions Batch` API to run either asynchronously (async) or synchronously (sync). The async API allows caller to batch up to **700** queries and sync API up to **100** queries.
      *
      * ### Download Asynchronous Batch Results
      * To download the async batch results you will issue a `GET` request to the batch download endpoint. This _download URL_ can be obtained from the `Location` header of a successful `POST` batch request and looks like the following:
@@ -552,14 +570,8 @@ export declare interface RequestRouteDirectionsBatch {
 
 export declare interface RequestRouteDirectionsBatchSync {
     /**
-     * **Route Directions Batch API**
-     *
      *
-     * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
-     *
-     *
-     *
-     * The Route Directions Batch API sends batches of queries to [Route Directions API](https://docs.microsoft.com/rest/api/maps/route/getroutedirections) using just a single API call. You can call Route Directions Batch API to run either asynchronously (async) or synchronously (sync). The async API allows caller to batch up to **700** queries and sync API up to **100** queries.
+     * The `Post Route Directions Batch Sync` API is an HTTP `POST` request that sends batches of queries to the [Get Route Directions](/rest/api/maps/route/get-route-directions) API using a single synchronous request. You can call `Route Directions Batch` API to run either asynchronously (async) or synchronously (sync). The async API allows caller to batch up to **700** queries and sync API up to **100** queries. To call the `Post Route Directions Batch` API in a asynchronous request, see [Post Route Directions Batch](/rest/api/maps/route/post-route-directions-batch).
      * ### 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.
      * ```
@@ -653,9 +665,7 @@ export declare interface RequestRouteDirectionsBatchSync {
 export declare interface RequestRouteMatrix {
     /**
      *
-     * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
-     *
-     * The Matrix Routing service allows calculation of a matrix of route summaries for a set of routes defined by origin and destination locations by using an asynchronous (async) or synchronous (sync) POST request. For every given origin, the service calculates the cost of routing from that origin to every given destination. The set of origins and the set of destinations can be thought of as the column and row headers of a table and each cell in the table contains the costs of routing from the origin to the destination for that cell. As an example, let's say a food delivery company has 20 drivers and they need to find the closest driver to pick up the delivery from the restaurant. To solve this use case, they can call Matrix Route API.
+     * The `Post Route Matrix` API is an HTTP `POST` request that allows calculation of a matrix of route summaries for a set of routes defined by origin and destination locations by using an asynchronous (async) request. To make a synchronous (sync) request, see [Post Route Matrix Sync](/rest/api/maps/route/post-route-matrix-sync). For every given origin, the service calculates the cost of routing from that origin to every given destination. The set of origins and the set of destinations can be thought of as the column and row headers of a table and each cell in the table contains the costs of routing from the origin to the destination for that cell. As an example, let's say a food delivery company has 20 drivers and they need to find the closest driver to pick up the delivery from the restaurant. To solve this use case, they can call Matrix Route API.
      *
      *
      * For each route, the travel times and distances are returned. You can use the computed costs to determine which detailed routes to calculate using the Route Directions API.
@@ -663,6 +673,9 @@ export declare interface RequestRouteMatrix {
      *
      * The maximum size of a matrix for async request is **700** and for sync request it's **100** (the number of origins multiplied by the number of destinations).
      *
+     * > [!NOTE]
+     * > All origins and destinations should be contained in an axis-aligned 400 km x 400 km bounding box. Otherwise some matrix cells will be resolved as OUT_OF_REGION.
+     *
      *
      *
      * ### Submit Synchronous Route Matrix Request
@@ -679,7 +692,7 @@ export declare interface RequestRouteMatrix {
      * The maximum size of a matrix for this API is **700** (the number of origins multiplied by the number of destinations). With that constraint in mind, examples of possible matrix dimensions are: 50x10, 10x10, 28x25. 10x70 (it does not need to be square).
      *
      *
-     * The asynchronous responses are stored for **14** days. The redirect URL returns a 404 response if used after the expiration period.
+     * The asynchronous responses are stored for **24** hours. The redirect URL returns a 404 response if used after the expiration period.
      *
      *
      *
@@ -724,9 +737,53 @@ export declare interface RequestRouteMatrix {
      */
     post(options: RouteRequestRouteMatrixParameters): StreamableMethod<RouteRequestRouteMatrix200Response | RouteRequestRouteMatrix202Response>;
     /**
-     * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
      *
-     * If the Matrix Route request was accepted successfully, the Location header in the response contains the URL to download the results of the request. This status URI looks like the following:
+     * The `Get Route Matrix` API is an HTTP `GET` request that computes the travel time and distance for all possible pairs in a list of origins and destinations. Unlike the [Get Route Directions](/rest/api/maps/route/get-route-directions) API, which provide detailed route instructions, this API focuses on efficiency by giving you the cost (travel time and distance) of routing from each origin to every destination.  For more information, see [Best practices for Azure Maps Route service](/azure/azure-maps/how-to-use-best-practices-for-routing).
+     *
+     * For every given origin, the service calculates the cost of routing from that origin to every given destination. The set of origins and the set of destinations can be thought of as the column and row headers of a table and each cell in the table contains the costs of routing from the origin to the destination for that cell. As an example, let's say a food delivery company has 20 drivers and they need to find the closest driver to pick up the delivery from the restaurant. To solve this use case, they can call Matrix Route API.
+     *
+     *
+     * For each route, the travel times and distances are returned. You can use the computed costs to determine which detailed routes to calculate using the Route Directions API.
+     *
+     *
+     * The maximum size of a matrix for async request is **700** and for sync request it's **100** (the number of origins multiplied by the number of destinations).
+     *
+     *
+     *
+     * ### Submit Synchronous Route Matrix Request
+     * If your scenario requires synchronous requests and the maximum size of the matrix is less than or equal to 100, you might want to make synchronous request. The maximum size of a matrix for this API is **100** (the number of origins multiplied by the number of destinations). With that constraint in mind, examples of possible matrix dimensions are: 10x10, 6x8, 9x8 (it does not need to be square).
+     *
+     * ```
+     * GET https://atlas.microsoft.com/route/matrix/sync/json?api-version=1.0&subscription-key={subscription-key}
+     * ```
+     *
+     * ### Submit Asynchronous Route Matrix Request
+     * The Asynchronous API is appropriate for processing big volumes of relatively complex routing requests. When you make a request by using async request, by default the service returns a 202 response code along a redirect URL in the Location field of the response header. This URL should be checked periodically until the response data or error information is available. If `waitForResults` parameter in the request is set to true, user will get a 200 response if the request is finished under 120 seconds.
+     *
+     *
+     * The maximum size of a matrix for this API is **700** (the number of origins multiplied by the number of destinations). With that constraint in mind, examples of possible matrix dimensions are: 50x10, 10x10, 28x25. 10x70 (it does not need to be square).
+     *
+     *
+     * The asynchronous responses are stored for **24** hours. The redirect URL returns a 404 response if used after the expiration period.
+     *
+     *
+     *
+     *
+     * ```
+     * GET https://atlas.microsoft.com/route/matrix/json?api-version=1.0&subscription-key={subscription-key}
+     * ```
+     *
+     * Here's a typical sequence of asynchronous operations:
+     * 1. Client sends a Route Matrix GET request to Azure Maps
+     *
+     * 2. The server will respond with one of the following:
+     *
+     *     > HTTP `202 Accepted` -  Route Matrix request has been accepted.
+     *
+     *     > HTTP `Error` - There was an error processing your Route Matrix request. This could either be a 400 Bad Request or any other Error status code.
+     *
+     *
+     * 3. If the Matrix Route request was accepted successfully, the Location header in the response contains the URL to download the results of the request. This status URI looks like the following:
      *
      *   ```
      *     GET https://atlas.microsoft.com/route/matrix/{matrixId}?api-version=1.0?subscription-key={subscription-key}
@@ -736,7 +793,7 @@ export declare interface RequestRouteMatrix {
      * 4. Client issues a GET request on the download URL obtained in Step 3 to download the results
      *
      * ### Download Sync Results
-     * When you make a POST request for Route Matrix Sync API, the service returns 200 response code for successful request and a response array. The response body will contain the data and there will be no possibility to retrieve the results later.
+     * When you make a GET request for Route Matrix Sync API, the service returns 200 response code for successful request and a response array. The response body will contain the data and there will be no possibility to retrieve the results later.
      *
      * ### Download Async Results
      * When a request issues a `202 Accepted` response, the request is being processed using our async pipeline. You will be given a URL to check the progress of your  async request in the location header of the response. This status URI looks like the following:
@@ -756,9 +813,7 @@ export declare interface RequestRouteMatrix {
 export declare interface RequestRouteMatrixSync {
     /**
      *
-     * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
-     *
-     * The Matrix Routing service allows calculation of a matrix of route summaries for a set of routes defined by origin and destination locations by using an asynchronous (async) or synchronous (sync) POST request. For every given origin, the service calculates the cost of routing from that origin to every given destination. The set of origins and the set of destinations can be thought of as the column and row headers of a table and each cell in the table contains the costs of routing from the origin to the destination for that cell. As an example, let's say a food delivery company has 20 drivers and they need to find the closest driver to pick up the delivery from the restaurant. To solve this use case, they can call Matrix Route API.
+     * The `Post Route Matrix Sync` API is an HTTP `POST` request that allows calculation of a matrix of route summaries for a set of routes defined by origin and destination locations by using a single synchronous (sync) request. To make an asynchronous (async) request, see [Post Route Matrix](/rest/api/maps/route/post-route-matrix). For every given origin, the service calculates the cost of routing from that origin to every given destination. The set of origins and the set of destinations can be thought of as the column and row headers of a table and each cell in the table contains the costs of routing from the origin to the destination for that cell. As an example, let's say a food delivery company has 20 drivers and they need to find the closest driver to pick up the delivery from the restaurant. To solve this use case, they can call Matrix Route API.
      *
      *
      * For each route, the travel times and distances are returned. You can use the computed costs to determine which detailed routes to calculate using the Route Directions API.
@@ -782,7 +837,7 @@ export declare interface RequestRouteMatrixSync {
      * The maximum size of a matrix for this API is **700** (the number of origins multiplied by the number of destinations). With that constraint in mind, examples of possible matrix dimensions are: 50x10, 10x10, 28x25. 10x70 (it does not need to be square).
      *
      *
-     * The asynchronous responses are stored for **14** days. The redirect URL returns a 404 response if used after the expiration period.
+     * The asynchronous responses are stored for **24** hours. The redirect URL returns a 404 response if used after the expiration period.
      *
      *
      *
@@ -841,9 +896,9 @@ export declare interface RouteDirectionParameters {
      *   ignored for the calculation of the reference route's travel time and traffic delay.
      */
     supportingPoints?: Record<string, unknown>;
-    /** This is a list of 3-character, ISO 3166-1, alpha-3 country codes of countries in which all toll roads with vignettes are to be avoided, e.g. "AUS,CHE". Toll roads with vignettes in countries not in the list are unaffected. Note: It is an error to specify both **avoidVignette** and **allowVignette**. */
+    /** This is a list of 3-character, ISO 3166-1, alpha-3 country codes of countries/regions in which all toll roads with vignettes are to be avoided, e.g. "AUS,CHE". Toll roads with vignettes in countries/regions not in the list are unaffected. Note: It is an error to specify both **avoidVignette** and **allowVignette**. */
     avoidVignette?: Array<string>;
-    /** This is a list of 3-character, ISO 3166-1, alpha-3 country codes of countries in which toll roads with vignettes are allowed, e.g. "AUS,CHE". Specifying **allowVignette** with some countries X is equivalent to specifying **avoidVignette** with all countries but X. Specifying **allowVignette** with an empty list is the same as avoiding all toll roads with vignettes. Note: It is an error to specify both **avoidVignette** and **allowVignette**. */
+    /** This is a list of 3-character, ISO 3166-1, alpha-3 country codes of countries/regions in which toll roads with vignettes are allowed, e.g. "AUS,CHE". Specifying **allowVignette** with some countries/regions X is equivalent to specifying **avoidVignette** with all countries/regions but X. Specifying **allowVignette** with an empty list is the same as avoiding all toll roads with vignettes. Note: It is an error to specify both **avoidVignette** and **allowVignette**. */
     allowVignette?: Array<string>;
     /** A GeoJSON MultiPolygon representing list of areas to avoid. Only rectangle polygons are supported. The maximum size of a rectangle is about 160x160 km. Maximum number of avoided areas is **10**. It cannot cross the 180th meridian. It must be between -80 and +80 degrees of latitude. */
     avoidAreas?: GeoJsonMultiPolygon;
@@ -852,7 +907,7 @@ export declare interface RouteDirectionParameters {
 /** An item returned from Route Directions Batch service call. */
 export declare interface RouteDirectionsBatchItemOutput extends BatchResultItemOutput {
     /** The result of the query. RouteDirections if the query completed successfully, ErrorResponse otherwise. */
-    response: RouteDirectionsBatchItemResponseOutput;
+    readonly response: RouteDirectionsBatchItemResponseOutput;
 }
 
 /** The result of the query. RouteDirections if the query completed successfully, ErrorResponse otherwise. */
@@ -862,15 +917,15 @@ export declare interface RouteDirectionsBatchItemResponseOutput extends RouteDir
 /** This object is returned from a successful Route Directions Batch service call. */
 export declare interface RouteDirectionsBatchResultOutput extends BatchResultOutput {
     /** Array containing the batch results. */
-    batchItems: Array<RouteDirectionsBatchItemOutput>;
+    readonly batchItems: Array<RouteDirectionsBatchItemOutput>;
 }
 
 /** This object is returned from a successful Route Directions call */
 export declare interface RouteDirectionsOutput {
     /** Format Version property */
-    formatVersion?: string;
+    readonly formatVersion?: string;
     /** Routes array */
-    routes: Array<RouteOutput>;
+    readonly routes: Array<RouteOutput>;
     /**
      * Optimized sequence of waypoints. It shows the index from the user provided waypoint sequence for the original and optimized list. For instance, a response:
      *
@@ -884,20 +939,18 @@ export declare interface RouteDirectionsOutput {
      *
      * means that the original sequence is [0, 1, 2] and optimized sequence is [1, 2, 0]. Since the index starts by 0 the original is "first, second, third" while the optimized is "second, third, first".
      */
-    optimizedWaypoints?: Array<RouteOptimizedWaypointOutput>;
+    readonly optimizedWaypoints?: Array<RouteOptimizedWaypointOutput>;
     /** Reports the effective settings used in the current call. */
     report?: RouteReportOutput;
 }
 
 /**
- * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
- *
  *
- * Returns  a route between an origin and a destination, passing through waypoints if they are specified. The route will take into account factors such as current traffic and the typical road speeds on the requested day of the week and time of day.
+ * The `Get Route Directions` API is an HTTP `GET` request that returns a route between an origin and a destination, passing through waypoints if specified. The route takes into account factors such as current traffic and the typical road speeds on the requested day of the week and time of day.
  *
  * Information returned includes the distance, estimated travel time, and a representation of the route geometry. Additional routing information such as optimized waypoint order or turn by turn instructions is also available, depending on the options selected.
  *
- * Routing service provides a set of parameters for a detailed description of vehicle-specific Consumption Model. Please check [Consumption Model](https://docs.microsoft.com/azure/azure-maps/consumption-model) for detailed explanation of the concepts and parameters involved.
+ * Routing service provides a set of parameters for a detailed description of a vehicle-specific consumption model. For more information, see [Consumption Model](/azure/azure-maps/consumption-model).
  */
 export declare interface RouteGetRouteDirections200Response extends HttpResponse {
     status: "200";
@@ -905,7 +958,8 @@ export declare interface RouteGetRouteDirections200Response extends HttpResponse
 }
 
 /**
- * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
+ *
+ * The `Get Route Directions Batch` API is an HTTP `GET` request that sends batches of queries to the [Get Route Directions](/rest/api/maps/route/get-route-directions) API using a single request. You can call `Get Route Directions Batch` API to run either asynchronously (async) or synchronously (sync). The async API allows caller to batch up to **700** queries and sync API up to **100** queries.
  *
  * ### Download Asynchronous Batch Results
  * To download the async batch results you will issue a `GET` request to the batch download endpoint. This _download URL_ can be obtained from the `Location` header of a successful `POST` batch request and looks like the following:
@@ -1011,12 +1065,13 @@ export declare interface RouteGetRouteDirectionsBatch200Response extends HttpRes
 }
 
 export declare interface RouteGetRouteDirectionsBatch202Headers {
-    /** New URL to check for the results of the long running process. */
+    /** New URL to check for the results of the long-running operation. */
     location?: string;
 }
 
 /**
- * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
+ *
+ * The `Get Route Directions Batch` API is an HTTP `GET` request that sends batches of queries to the [Get Route Directions](/rest/api/maps/route/get-route-directions) API using a single request. You can call `Get Route Directions Batch` API to run either asynchronously (async) or synchronously (sync). The async API allows caller to batch up to **700** queries and sync API up to **100** queries.
  *
  * ### Download Asynchronous Batch Results
  * To download the async batch results you will issue a `GET` request to the batch download endpoint. This _download URL_ can be obtained from the `Location` header of a successful `POST` batch request and looks like the following:
@@ -1118,21 +1173,18 @@ export declare interface RouteGetRouteDirectionsBatch202Headers {
  */
 export declare interface RouteGetRouteDirectionsBatch202Response extends HttpResponse {
     status: "202";
-    body: Record<string, unknown>;
     headers: RawHttpHeaders & RouteGetRouteDirectionsBatch202Headers;
 }
 
 export declare type RouteGetRouteDirectionsBatchParameters = RequestParameters;
 
 /**
- * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
  *
- *
- * Returns  a route between an origin and a destination, passing through waypoints if they are specified. The route will take into account factors such as current traffic and the typical road speeds on the requested day of the week and time of day.
+ * The `Get Route Directions` API is an HTTP `GET` request that returns a route between an origin and a destination, passing through waypoints if specified. The route takes into account factors such as current traffic and the typical road speeds on the requested day of the week and time of day.
  *
  * Information returned includes the distance, estimated travel time, and a representation of the route geometry. Additional routing information such as optimized waypoint order or turn by turn instructions is also available, depending on the options selected.
  *
- * Routing service provides a set of parameters for a detailed description of vehicle-specific Consumption Model. Please check [Consumption Model](https://docs.microsoft.com/azure/azure-maps/consumption-model) for detailed explanation of the concepts and parameters involved.
+ * Routing service provides a set of parameters for a detailed description of a vehicle-specific consumption model. For more information, see [Consumption Model](/azure/azure-maps/consumption-model).
  */
 export declare interface RouteGetRouteDirectionsDefaultResponse extends HttpResponse {
     status: string;
@@ -1154,9 +1206,27 @@ export declare interface RouteGetRouteDirectionsQueryParamProperties {
     alternativeType?: "anyRoute" | "betterRoute";
     /** All alternative routes returned will follow the reference route (see section POST Requests) from the origin point of the calculateRoute request for at least this number of meters. Can only be used when reconstructing a route. The minDeviationDistance parameter cannot be used in conjunction with arriveAt */
     minDeviationDistance?: number;
-    /** The date and time of arrival at the destination point. It must be specified as a dateTime. When a time zone offset is not specified it will be assumed to be that of the destination point. The arriveAt value must be in the future. The arriveAt parameter cannot be used in conjunction with departAt, minDeviationDistance or minDeviationTime. */
+    /**
+     * The date and time of arrival at the destination point formatted as a `dateTime` value as defined in [RFC 3339, section 5.6](https://www.rfc-editor.org/rfc/rfc3339#section-5.6), with an optional time zone offset. When a time zone offset is not specified it will be assumed to be that of the destination point.
+     *
+     * Examples:
+     *   * 2023-12-19T16:39:57
+     *   * 2023-12-19T16:39:57-08:00
+     *
+     * The `arriveAt` parameter cannot be used in conjunction with `departAt`, `minDeviationDistance` or `minDeviationTime`.
+     */
     arriveAt?: Date | string;
-    /** The date and time of departure from the origin point. Departure times apart from now must be specified as a dateTime. When a time zone offset is not specified, it will be assumed to be that of the origin point. The departAt value must be in the future in the date-time format (1996-12-19T16:39:57-08:00). */
+    /**
+     * The date and time of departure from the origin point formatted as a `dateTime` value as defined in [RFC 3339, section 5.6](https://www.rfc-editor.org/rfc/rfc3339#section-5.6), with an optional time zone offset. When a time zone offset is not specified, it will be assumed to be that of the origin point.
+     *   * Default value: now
+     *   * Other value: `dateTime`
+     *
+     * Examples:
+     *   * 2023-12-19T16:39:57
+     *   * 2023-12-19T16:39:57-08:00
+     *
+     * The `departAt` parameter cannot be used in conjunction with `arriveAt`.
+     */
     departAt?: Date | string;
     /**
      * All alternative routes returned will follow the reference route (see section POST Requests) from the origin point of the calculateRoute request for at least this number of seconds. Can only be used when reconstructing a route. The minDeviationTime parameter cannot be used in conjunction with arriveAt. Default value is 0. Setting )minDeviationTime_ to a value greater than zero has the following consequences:
@@ -1177,7 +1247,7 @@ export declare interface RouteGetRouteDirectionsQueryParamProperties {
      *   - The _vehicleHeading_ is ignored.
      */
     minDeviationTime?: number;
-    /** If specified, guidance instructions will be returned. Note that the instructionsType parameter cannot be used in conjunction with routeRepresentation=none */
+    /** If specified, guidance instructions will be returned. Note that the instructionsType parameter cannot be used in conjunction with routeRepresentation=none. */
     instructionsType?: "coded" | "text" | "tagged";
     /**
      * The language parameter determines the language of the guidance messages. Proper nouns (the names of streets, plazas, etc.) are returned in the specified  language, or if that is not available, they are returned in an available language  that is close to it. Allowed values are (a subset of) the IETF language tags. The currently supported  languages are listed in the [Supported languages  section](https://docs.microsoft.com/azure/azure-maps/supported-languages).
@@ -1187,7 +1257,7 @@ export declare interface RouteGetRouteDirectionsQueryParamProperties {
     language?: string;
     /** Re-order the route waypoints using a fast heuristic algorithm to reduce the route length. Yields best results when used in conjunction with routeType _shortest_. Notice that origin and destination are excluded from the optimized waypoint indices. To include origin and destination in the response, please increase all the indices by 1 to account for the origin, and then add the destination as the final index. Possible values are true or false. True computes a better order if possible, but is not allowed to be used in conjunction with maxAlternatives value greater than 0 or in conjunction with circle waypoints. False will use the locations in the given order and not allowed to be used in conjunction with routeRepresentation _none_. */
     computeBestOrder?: boolean;
-    /** Specifies the representation of the set of routes provided as response. This parameter value can only be used in conjunction with computeBestOrder=true. */
+    /** Specifies the representation of the set of routes provided as response. */
     routeRepresentation?: "polyline" | "summaryOnly" | "none";
     /** Specifies whether to return additional travel times using different types of traffic information (none, historic, live) as well as the default best-estimate travel time. */
     computeTravelTimeFor?: "none" | "all";
@@ -1195,8 +1265,8 @@ export declare interface RouteGetRouteDirectionsQueryParamProperties {
     vehicleHeading?: number;
     /** Specifies which data should be reported for diagnosis purposes. The only possible value is _effectiveSettings_. Reports the effective parameters or data used when calling the API. In the case of defaulted parameters the default will be reflected where the parameter was not specified by the caller. */
     report?: "effectiveSettings";
-    /** Specifies which of the section types is reported in the route response. <br><br>For example if sectionType = pedestrian the sections which are suited for pedestrians only are returned. Multiple types can be used. The default sectionType refers to the travelMode input. By default travelMode is set to car */
-    sectionType?: "carTrain" | "country" | "ferry" | "motorway" | "pedestrian" | "tollRoad" | "tollVignette" | "traffic" | "travelMode" | "tunnel" | "carpool" | "urban";
+    /** Specifies which of the section types is reported in the route response. <br><br>For example if sectionType = pedestrian the sections which are suited for pedestrians only are returned. Can be specified multiple times in one request, for example, '&sectionType=carTrain&sectionType=pedestrian&sectionType=motorway'. The default sectionType refers to the travelMode input. By default travelMode is set to car */
+    sectionType?: Array<"carTrain" | "country" | "ferry" | "motorway" | "pedestrian" | "tollRoad" | "tollVignette" | "traffic" | "travelMode" | "tunnel" | "carpool" | "urban">;
     /** Weight per axle of the vehicle in kg. A value of 0 means that weight restrictions per axle are not considered. */
     vehicleAxleWeight?: number;
     /** Width of the vehicle in meters. A value of 0 means that width restrictions are not considered. */
@@ -1233,9 +1303,9 @@ export declare interface RouteGetRouteDirectionsQueryParamProperties {
     windingness?: "low" | "normal" | "high";
     /** Degree of hilliness for thrilling route. This parameter can only be used in conjunction with `routeType`=thrilling. */
     hilliness?: "low" | "normal" | "high";
-    /** The mode of travel for the requested route. If not defined, default is 'car'. Note that the requested travelMode may not be available for the entire route. Where the requested travelMode is not available for a particular section, the travelMode element of the response for that section will be "other". Note that travel modes bus, motorcycle, taxi and van are BETA functionality. Full restriction data is not available in all areas. In **calculateReachableRange** requests, the values bicycle and pedestrian must not be used. */
+    /** The mode of travel for the requested route. If not defined, default is 'car'. Note that the requested travelMode may not be available for the entire route. Where the requested travelMode is not available for a particular section, the travelMode element of the response for that section will be "other". Note that travel modes bus, motorcycle, taxi and van are BETA functionality. Full restriction data is not available in all areas. */
     travelMode?: "car" | "truck" | "taxi" | "bus" | "van" | "motorcycle" | "bicycle" | "pedestrian";
-    /** Specifies something that the route calculation should try to avoid when determining the route. Can be specified multiple times in one request, for example, '&avoid=motorways&avoid=tollRoads&avoid=ferries'. In calculateReachableRange requests, the value alreadyUsedRoads must not be used. */
+    /** Specifies something that the route calculation should try to avoid when determining the route. Can be specified multiple times in one request, for example, '&avoid=motorways&avoid=tollRoads&avoid=ferries'. In Route Range requests, the value alreadyUsedRoads must not be used. */
     avoid?: Array<"tollRoads" | "motorways" | "ferries" | "unpavedRoads" | "carpools" | "alreadyUsedRoads" | "borderCrossings">;
     /**
      * Possible values:
@@ -1246,7 +1316,7 @@ export declare interface RouteGetRouteDirectionsQueryParamProperties {
     traffic?: boolean;
     /** The type of route requested. */
     routeType?: "fastest" | "shortest" | "eco" | "thrilling";
-    /** Types of cargo that may be classified as hazardous materials and restricted from some roads. Available vehicleLoadType values are US Hazmat classes 1 through 9, plus generic classifications for use in other countries. Values beginning with USHazmat are for US routing while otherHazmat should be used for all other countries. vehicleLoadType can be specified multiple times. This parameter is currently only considered for travelMode=truck. */
+    /** Types of cargo that may be classified as hazardous materials and restricted from some roads. Available vehicleLoadType values are US Hazmat classes 1 through 9, plus generic classifications for use in other countries/regions. Values beginning with USHazmat are for US routing while otherHazmat should be used for all other countries/regions. vehicleLoadType can be specified multiple times. This parameter is currently only considered for travelMode=truck. */
     vehicleLoadType?: "USHazmatClass1" | "USHazmatClass2" | "USHazmatClass3" | "USHazmatClass4" | "USHazmatClass5" | "USHazmatClass6" | "USHazmatClass7" | "USHazmatClass8" | "USHazmatClass9" | "otherHazmatExplosive" | "otherHazmatGeneral" | "otherHazmatHarmfulToWater";
     /** Engine type of the vehicle. When a detailed Consumption Model is specified, it must be consistent with the value of **vehicleEngineType**. */
     vehicleEngineType?: "combustion" | "electric";
@@ -1388,10 +1458,8 @@ export declare interface RouteGetRouteDirectionsQueryParamProperties {
 }
 
 /**
- * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
  *
- *
- * Returns  a route between an origin and a destination, passing through waypoints if they are specified. The route will take into account factors such as current traffic and the typical road speeds on the requested day of the week and time of day.
+ * The `Post Route Directions` API is an HTTP `POST` request that returns a route between an origin and a destination, passing through waypoints if they are specified. The route will take into account factors such as current traffic and the typical road speeds on the requested day of the week and time of day.
  *
  * Information returned includes the distance, estimated travel time, and a representation of the route geometry. Additional routing information such as optimized waypoint order or turn by turn instructions is also available, depending on the options selected.
  *
@@ -1418,10 +1486,8 @@ export declare interface RouteGetRouteDirectionsWithAdditionalParametersBodyPara
 }
 
 /**
- * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
- *
  *
- * Returns  a route between an origin and a destination, passing through waypoints if they are specified. The route will take into account factors such as current traffic and the typical road speeds on the requested day of the week and time of day.
+ * The `Post Route Directions` API is an HTTP `POST` request that returns a route between an origin and a destination, passing through waypoints if they are specified. The route will take into account factors such as current traffic and the typical road speeds on the requested day of the week and time of day.
  *
  * Information returned includes the distance, estimated travel time, and a representation of the route geometry. Additional routing information such as optimized waypoint order or turn by turn instructions is also available, depending on the options selected.
  *
@@ -1471,13 +1537,13 @@ export declare interface RouteGetRouteDirectionsWithAdditionalParametersQueryPar
      *   - The _vehicleHeading_ is ignored.
      */
     minDeviationTime?: number;
-    /** If specified, guidance instructions will be returned. Note that the instructionsType parameter cannot be used in conjunction with routeRepresentation=none */
+    /** If specified, guidance instructions will be returned. Note that the instructionsType parameter cannot be used in conjunction with routeRepresentation=none. */
     instructionsType?: "coded" | "text" | "tagged";
     /** The language parameter determines the language of the guidance messages. It does not affect proper nouns (the names of streets, plazas, etc.) It has no effect when instructionsType=coded. Allowed values are (a subset of) the IETF language tags described */
     language?: string;
     /** Re-order the route waypoints using a fast heuristic algorithm to reduce the route length. Yields best results when used in conjunction with routeType _shortest_. Notice that origin and destination are excluded from the optimized waypoint indices. To include origin and destination in the response, please increase all the indices by 1 to account for the origin, and then add the destination as the final index. Possible values are true or false. True computes a better order if possible, but is not allowed to be used in conjunction with maxAlternatives value greater than 0 or in conjunction with circle waypoints. False will use the locations in the given order and not allowed to be used in conjunction with routeRepresentation _none_. */
     computeBestOrder?: boolean;
-    /** Specifies the representation of the set of routes provided as response. This parameter value can only be used in conjunction with computeBestOrder=true. */
+    /** Specifies the representation of the set of routes provided as response. */
     routeRepresentation?: "polyline" | "summaryOnly" | "none";
     /** Specifies whether to return additional travel times using different types of traffic information (none, historic, live) as well as the default best-estimate travel time. */
     computeTravelTimeFor?: "none" | "all";
@@ -1485,11 +1551,29 @@ export declare interface RouteGetRouteDirectionsWithAdditionalParametersQueryPar
     vehicleHeading?: number;
     /** Specifies which data should be reported for diagnosis purposes. The only possible value is _effectiveSettings_. Reports the effective parameters or data used when calling the API. In the case of defaulted parameters the default will be reflected where the parameter was not specified by the caller. */
     report?: "effectiveSettings";
-    /** Specifies which of the section types is reported in the route response. <br><br>For example if sectionType = pedestrian the sections which are suited for pedestrians only are returned. Multiple types can be used. The default sectionType refers to the travelMode input. By default travelMode is set to car */
-    sectionType?: "carTrain" | "country" | "ferry" | "motorway" | "pedestrian" | "tollRoad" | "tollVignette" | "traffic" | "travelMode" | "tunnel" | "carpool" | "urban";
-    /** The date and time of arrival at the destination point. It must be specified as a dateTime. When a time zone offset is not specified it will be assumed to be that of the destination point. The arriveAt value must be in the future. The arriveAt parameter cannot be used in conjunction with departAt, minDeviationDistance or minDeviationTime. */
+    /** Specifies which of the section types is reported in the route response. <br><br>For example if sectionType = pedestrian the sections which are suited for pedestrians only are returned. Can be specified multiple times in one request, for example, '&sectionType=carTrain&sectionType=pedestrian&sectionType=motorway'. The default sectionType refers to the travelMode input. By default travelMode is set to car */
+    sectionType?: Array<"carTrain" | "country" | "ferry" | "motorway" | "pedestrian" | "tollRoad" | "tollVignette" | "traffic" | "travelMode" | "tunnel" | "carpool" | "urban">;
+    /**
+     * The date and time of arrival at the destination point formatted as a `dateTime` value as defined in [RFC 3339, section 5.6](https://www.rfc-editor.org/rfc/rfc3339#section-5.6), with an optional time zone offset. When a time zone offset is not specified it will be assumed to be that of the destination point.
+     *
+     * Examples:
+     *   * 2023-12-19T16:39:57
+     *   * 2023-12-19T16:39:57-08:00
+     *
+     * The `arriveAt` parameter cannot be used in conjunction with `departAt`, `minDeviationDistance` or `minDeviationTime`.
+     */
     arriveAt?: Date | string;
-    /** The date and time of departure from the origin point. Departure times apart from now must be specified as a dateTime. When a time zone offset is not specified, it will be assumed to be that of the origin point. The departAt value must be in the future in the date-time format (1996-12-19T16:39:57-08:00). */
+    /**
+     * The date and time of departure from the origin point formatted as a `dateTime` value as defined in [RFC 3339, section 5.6](https://www.rfc-editor.org/rfc/rfc3339#section-5.6), with an optional time zone offset. When a time zone offset is not specified, it will be assumed to be that of the origin point.
+     *   * Default value: now
+     *   * Other value: `dateTime`
+     *
+     * Examples:
+     *   * 2023-12-19T16:39:57
+     *   * 2023-12-19T16:39:57-08:00
+     *
+     * The `departAt` parameter cannot be used in conjunction with `arriveAt`.
+     */
     departAt?: Date | string;
     /** Weight per axle of the vehicle in kg. A value of 0 means that weight restrictions per axle are not considered. */
     vehicleAxleWeight?: number;
@@ -1527,9 +1611,9 @@ export declare interface RouteGetRouteDirectionsWithAdditionalParametersQueryPar
     windingness?: "low" | "normal" | "high";
     /** Degree of hilliness for thrilling route. This parameter can only be used in conjunction with `routeType`=thrilling. */
     hilliness?: "low" | "normal" | "high";
-    /** The mode of travel for the requested route. If not defined, default is 'car'. Note that the requested travelMode may not be available for the entire route. Where the requested travelMode is not available for a particular section, the travelMode element of the response for that section will be "other". Note that travel modes bus, motorcycle, taxi and van are BETA functionality. Full restriction data is not available in all areas. In **calculateReachableRange** requests, the values bicycle and pedestrian must not be used. */
+    /** The mode of travel for the requested route. If not defined, default is 'car'. Note that the requested travelMode may not be available for the entire route. Where the requested travelMode is not available for a particular section, the travelMode element of the response for that section will be "other". Note that travel modes bus, motorcycle, taxi and van are BETA functionality. Full restriction data is not available in all areas. */
     travelMode?: "car" | "truck" | "taxi" | "bus" | "van" | "motorcycle" | "bicycle" | "pedestrian";
-    /** Specifies something that the route calculation should try to avoid when determining the route. Can be specified multiple times in one request, for example, '&avoid=motorways&avoid=tollRoads&avoid=ferries'. In calculateReachableRange requests, the value alreadyUsedRoads must not be used. */
+    /** Specifies something that the route calculation should try to avoid when determining the route. Can be specified multiple times in one request, for example, '&avoid=motorways&avoid=tollRoads&avoid=ferries'. In Route Range requests, the value alreadyUsedRoads must not be used. */
     avoid?: Array<"tollRoads" | "motorways" | "ferries" | "unpavedRoads" | "carpools" | "alreadyUsedRoads" | "borderCrossings">;
     /**
      * Possible values:
@@ -1540,7 +1624,7 @@ export declare interface RouteGetRouteDirectionsWithAdditionalParametersQueryPar
     traffic?: boolean;
     /** The type of route requested. */
     routeType?: "fastest" | "shortest" | "eco" | "thrilling";
-    /** Types of cargo that may be classified as hazardous materials and restricted from some roads. Available vehicleLoadType values are US Hazmat classes 1 through 9, plus generic classifications for use in other countries. Values beginning with USHazmat are for US routing while otherHazmat should be used for all other countries. vehicleLoadType can be specified multiple times. This parameter is currently only considered for travelMode=truck. */
+    /** Types of cargo that may be classified as hazardous materials and restricted from some roads. Available vehicleLoadType values are US Hazmat classes 1 through 9, plus generic classifications for use in other countries/regions. Values beginning with USHazmat are for US routing while otherHazmat should be used for all other countries/regions. vehicleLoadType can be specified multiple times. This parameter is currently only considered for travelMode=truck. */
     vehicleLoadType?: "USHazmatClass1" | "USHazmatClass2" | "USHazmatClass3" | "USHazmatClass4" | "USHazmatClass5" | "USHazmatClass6" | "USHazmatClass7" | "USHazmatClass8" | "USHazmatClass9" | "otherHazmatExplosive" | "otherHazmatGeneral" | "otherHazmatHarmfulToWater";
     /** Engine type of the vehicle. When a detailed Consumption Model is specified, it must be consistent with the value of **vehicleEngineType**. */
     vehicleEngineType?: "combustion" | "electric";
@@ -1682,9 +1766,53 @@ export declare interface RouteGetRouteDirectionsWithAdditionalParametersQueryPar
 }
 
 /**
- * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
  *
- * If the Matrix Route request was accepted successfully, the Location header in the response contains the URL to download the results of the request. This status URI looks like the following:
+ * The `Get Route Matrix` API is an HTTP `GET` request that computes the travel time and distance for all possible pairs in a list of origins and destinations. Unlike the [Get Route Directions](/rest/api/maps/route/get-route-directions) API, which provide detailed route instructions, this API focuses on efficiency by giving you the cost (travel time and distance) of routing from each origin to every destination.  For more information, see [Best practices for Azure Maps Route service](/azure/azure-maps/how-to-use-best-practices-for-routing).
+ *
+ * For every given origin, the service calculates the cost of routing from that origin to every given destination. The set of origins and the set of destinations can be thought of as the column and row headers of a table and each cell in the table contains the costs of routing from the origin to the destination for that cell. As an example, let's say a food delivery company has 20 drivers and they need to find the closest driver to pick up the delivery from the restaurant. To solve this use case, they can call Matrix Route API.
+ *
+ *
+ * For each route, the travel times and distances are returned. You can use the computed costs to determine which detailed routes to calculate using the Route Directions API.
+ *
+ *
+ * The maximum size of a matrix for async request is **700** and for sync request it's **100** (the number of origins multiplied by the number of destinations).
+ *
+ *
+ *
+ * ### Submit Synchronous Route Matrix Request
+ * If your scenario requires synchronous requests and the maximum size of the matrix is less than or equal to 100, you might want to make synchronous request. The maximum size of a matrix for this API is **100** (the number of origins multiplied by the number of destinations). With that constraint in mind, examples of possible matrix dimensions are: 10x10, 6x8, 9x8 (it does not need to be square).
+ *
+ * ```
+ * GET https://atlas.microsoft.com/route/matrix/sync/json?api-version=1.0&subscription-key={subscription-key}
+ * ```
+ *
+ * ### Submit Asynchronous Route Matrix Request
+ * The Asynchronous API is appropriate for processing big volumes of relatively complex routing requests. When you make a request by using async request, by default the service returns a 202 response code along a redirect URL in the Location field of the response header. This URL should be checked periodically until the response data or error information is available. If `waitForResults` parameter in the request is set to true, user will get a 200 response if the request is finished under 120 seconds.
+ *
+ *
+ * The maximum size of a matrix for this API is **700** (the number of origins multiplied by the number of destinations). With that constraint in mind, examples of possible matrix dimensions are: 50x10, 10x10, 28x25. 10x70 (it does not need to be square).
+ *
+ *
+ * The asynchronous responses are stored for **24** hours. The redirect URL returns a 404 response if used after the expiration period.
+ *
+ *
+ *
+ *
+ * ```
+ * GET https://atlas.microsoft.com/route/matrix/json?api-version=1.0&subscription-key={subscription-key}
+ * ```
+ *
+ * Here's a typical sequence of asynchronous operations:
+ * 1. Client sends a Route Matrix GET request to Azure Maps
+ *
+ * 2. The server will respond with one of the following:
+ *
+ *     > HTTP `202 Accepted` -  Route Matrix request has been accepted.
+ *
+ *     > HTTP `Error` - There was an error processing your Route Matrix request. This could either be a 400 Bad Request or any other Error status code.
+ *
+ *
+ * 3. If the Matrix Route request was accepted successfully, the Location header in the response contains the URL to download the results of the request. This status URI looks like the following:
  *
  *   ```
  *     GET https://atlas.microsoft.com/route/matrix/{matrixId}?api-version=1.0?subscription-key={subscription-key}
@@ -1694,7 +1822,7 @@ export declare interface RouteGetRouteDirectionsWithAdditionalParametersQueryPar
  * 4. Client issues a GET request on the download URL obtained in Step 3 to download the results
  *
  * ### Download Sync Results
- * When you make a POST request for Route Matrix Sync API, the service returns 200 response code for successful request and a response array. The response body will contain the data and there will be no possibility to retrieve the results later.
+ * When you make a GET request for Route Matrix Sync API, the service returns 200 response code for successful request and a response array. The response body will contain the data and there will be no possibility to retrieve the results later.
  *
  * ### Download Async Results
  * When a request issues a `202 Accepted` response, the request is being processed using our async pipeline. You will be given a URL to check the progress of your  async request in the location header of the response. This status URI looks like the following:
@@ -1714,14 +1842,58 @@ export declare interface RouteGetRouteMatrix200Response extends HttpResponse {
 }
 
 export declare interface RouteGetRouteMatrix202Headers {
-    /** New URL to check for the results of the long running process. */
+    /** New URL to check for the results of the long-running operation. */
     location?: string;
 }
 
 /**
- * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
  *
- * If the Matrix Route request was accepted successfully, the Location header in the response contains the URL to download the results of the request. This status URI looks like the following:
+ * The `Get Route Matrix` API is an HTTP `GET` request that computes the travel time and distance for all possible pairs in a list of origins and destinations. Unlike the [Get Route Directions](/rest/api/maps/route/get-route-directions) API, which provide detailed route instructions, this API focuses on efficiency by giving you the cost (travel time and distance) of routing from each origin to every destination.  For more information, see [Best practices for Azure Maps Route service](/azure/azure-maps/how-to-use-best-practices-for-routing).
+ *
+ * For every given origin, the service calculates the cost of routing from that origin to every given destination. The set of origins and the set of destinations can be thought of as the column and row headers of a table and each cell in the table contains the costs of routing from the origin to the destination for that cell. As an example, let's say a food delivery company has 20 drivers and they need to find the closest driver to pick up the delivery from the restaurant. To solve this use case, they can call Matrix Route API.
+ *
+ *
+ * For each route, the travel times and distances are returned. You can use the computed costs to determine which detailed routes to calculate using the Route Directions API.
+ *
+ *
+ * The maximum size of a matrix for async request is **700** and for sync request it's **100** (the number of origins multiplied by the number of destinations).
+ *
+ *
+ *
+ * ### Submit Synchronous Route Matrix Request
+ * If your scenario requires synchronous requests and the maximum size of the matrix is less than or equal to 100, you might want to make synchronous request. The maximum size of a matrix for this API is **100** (the number of origins multiplied by the number of destinations). With that constraint in mind, examples of possible matrix dimensions are: 10x10, 6x8, 9x8 (it does not need to be square).
+ *
+ * ```
+ * GET https://atlas.microsoft.com/route/matrix/sync/json?api-version=1.0&subscription-key={subscription-key}
+ * ```
+ *
+ * ### Submit Asynchronous Route Matrix Request
+ * The Asynchronous API is appropriate for processing big volumes of relatively complex routing requests. When you make a request by using async request, by default the service returns a 202 response code along a redirect URL in the Location field of the response header. This URL should be checked periodically until the response data or error information is available. If `waitForResults` parameter in the request is set to true, user will get a 200 response if the request is finished under 120 seconds.
+ *
+ *
+ * The maximum size of a matrix for this API is **700** (the number of origins multiplied by the number of destinations). With that constraint in mind, examples of possible matrix dimensions are: 50x10, 10x10, 28x25. 10x70 (it does not need to be square).
+ *
+ *
+ * The asynchronous responses are stored for **24** hours. The redirect URL returns a 404 response if used after the expiration period.
+ *
+ *
+ *
+ *
+ * ```
+ * GET https://atlas.microsoft.com/route/matrix/json?api-version=1.0&subscription-key={subscription-key}
+ * ```
+ *
+ * Here's a typical sequence of asynchronous operations:
+ * 1. Client sends a Route Matrix GET request to Azure Maps
+ *
+ * 2. The server will respond with one of the following:
+ *
+ *     > HTTP `202 Accepted` -  Route Matrix request has been accepted.
+ *
+ *     > HTTP `Error` - There was an error processing your Route Matrix request. This could either be a 400 Bad Request or any other Error status code.
+ *
+ *
+ * 3. If the Matrix Route request was accepted successfully, the Location header in the response contains the URL to download the results of the request. This status URI looks like the following:
  *
  *   ```
  *     GET https://atlas.microsoft.com/route/matrix/{matrixId}?api-version=1.0?subscription-key={subscription-key}
@@ -1731,7 +1903,7 @@ export declare interface RouteGetRouteMatrix202Headers {
  * 4. Client issues a GET request on the download URL obtained in Step 3 to download the results
  *
  * ### Download Sync Results
- * When you make a POST request for Route Matrix Sync API, the service returns 200 response code for successful request and a response array. The response body will contain the data and there will be no possibility to retrieve the results later.
+ * When you make a GET request for Route Matrix Sync API, the service returns 200 response code for successful request and a response array. The response body will contain the data and there will be no possibility to retrieve the results later.
  *
  * ### Download Async Results
  * When a request issues a `202 Accepted` response, the request is being processed using our async pipeline. You will be given a URL to check the progress of your  async request in the location header of the response. This status URI looks like the following:
@@ -1747,21 +1919,16 @@ export declare interface RouteGetRouteMatrix202Headers {
  */
 export declare interface RouteGetRouteMatrix202Response extends HttpResponse {
     status: "202";
-    body: Record<string, unknown>;
     headers: RawHttpHeaders & RouteGetRouteMatrix202Headers;
 }
 
 export declare type RouteGetRouteMatrixParameters = RequestParameters;
 
 /**
- * __Route Range (Isochrone) API__
  *
+ * The `Get Route Range` (Isochrone) API is an HTTP `GET` request that will calculate a set of locations that can be reached from the origin point based on fuel, energy, time or distance budget that is specified. A polygon boundary (or Isochrone) is returned in a counterclockwise  orientation as well as the precise polygon center which was the result of the origin point.
  *
- * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
- *
- * This service will calculate a set of locations that can be reached from the origin point based on fuel, energy,  time or distance budget that is specified. A polygon boundary (or Isochrone) is returned in a counterclockwise  orientation as well as the precise polygon center which was the result of the origin point.
- *
- * The returned polygon can be used for further processing such as  [Search Inside Geometry](https://docs.microsoft.com/rest/api/maps/search/postsearchinsidegeometry) to  search for POIs within the provided Isochrone.
+ * The returned polygon can be used for further processing such as  [Search Inside Geometry](/rest/api/maps/search/post-search-inside-geometry) to  search for POIs within the provided isochrone.
  */
 export declare interface RouteGetRouteRange200Response extends HttpResponse {
     status: "200";
@@ -1769,14 +1936,10 @@ export declare interface RouteGetRouteRange200Response extends HttpResponse {
 }
 
 /**
- * __Route Range (Isochrone) API__
- *
- *
- * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
  *
- * This service will calculate a set of locations that can be reached from the origin point based on fuel, energy,  time or distance budget that is specified. A polygon boundary (or Isochrone) is returned in a counterclockwise  orientation as well as the precise polygon center which was the result of the origin point.
+ * The `Get Route Range` (Isochrone) API is an HTTP `GET` request that will calculate a set of locations that can be reached from the origin point based on fuel, energy, time or distance budget that is specified. A polygon boundary (or Isochrone) is returned in a counterclockwise  orientation as well as the precise polygon center which was the result of the origin point.
  *
- * The returned polygon can be used for further processing such as  [Search Inside Geometry](https://docs.microsoft.com/rest/api/maps/search/postsearchinsidegeometry) to  search for POIs within the provided Isochrone.
+ * The returned polygon can be used for further processing such as  [Search Inside Geometry](/rest/api/maps/search/post-search-inside-geometry) to  search for POIs within the provided isochrone.
  */
 export declare interface RouteGetRouteRangeDefaultResponse extends HttpResponse {
     status: string;
@@ -1800,7 +1963,17 @@ export declare interface RouteGetRouteRangeQueryParamProperties {
     timeBudgetInSec?: number;
     /** Distance budget in meters that determines maximal range which can be travelled using driving distance.  The Consumption Model will only affect the range when routeType is eco.<br> Exactly one budget (fuelBudgetInLiters, energyBudgetInkWh, timeBudgetInSec, or distanceBudgetInMeters) must be used. */
     distanceBudgetInMeters?: number;
-    /** The date and time of departure from the origin point. Departure times apart from now must be specified as a dateTime. When a time zone offset is not specified, it will be assumed to be that of the origin point. The departAt value must be in the future in the date-time format (1996-12-19T16:39:57-08:00). */
+    /**
+     * The date and time of departure from the origin point formatted as a `dateTime` value as defined in [RFC 3339, section 5.6](https://www.rfc-editor.org/rfc/rfc3339#section-5.6), with an optional time zone offset. When a time zone offset is not specified, it will be assumed to be that of the origin point.
+     *   * Default value: now
+     *   * Other value: `dateTime`
+     *
+     * Examples:
+     *   * 2023-12-19T16:39:57
+     *   * 2023-12-19T16:39:57-08:00
+     *
+     * The `departAt` parameter cannot be used in conjunction with `arriveAt`.
+     */
     departAt?: Date | string;
     /** The type of route requested. */
     routeType?: "fastest" | "shortest" | "eco" | "thrilling";
@@ -1811,9 +1984,9 @@ export declare interface RouteGetRouteRangeQueryParamProperties {
      *   during routing, the effect of historic traffic on effective road speeds is still incorporated.
      */
     traffic?: boolean;
-    /** Specifies something that the route calculation should try to avoid when determining the route. Can be specified multiple times in one request, for example, '&avoid=motorways&avoid=tollRoads&avoid=ferries'. In calculateReachableRange requests, the value alreadyUsedRoads must not be used. */
+    /** Specifies something that the route calculation should try to avoid when determining the route. Can be specified multiple times in one request, for example, '&avoid=motorways&avoid=tollRoads&avoid=ferries'. In Route Range requests, the value alreadyUsedRoads must not be used. */
     avoid?: Array<"tollRoads" | "motorways" | "ferries" | "unpavedRoads" | "carpools" | "alreadyUsedRoads" | "borderCrossings">;
-    /** The mode of travel for the requested route. If not defined, default is 'car'. Note that the requested travelMode may not be available for the entire route. Where the requested travelMode is not available for a particular section, the travelMode element of the response for that section will be "other". Note that travel modes bus, motorcycle, taxi and van are BETA functionality. Full restriction data is not available in all areas. In **calculateReachableRange** requests, the values bicycle and pedestrian must not be used. */
+    /** The mode of travel for the requested route. If not defined, default is 'car'. Note that the requested travelMode may not be available for the entire route. Where the requested travelMode is not available for a particular section, the travelMode element of the response for that section will be "other". Note that travel modes bus, motorcycle, taxi and van are BETA functionality. Full restriction data is not available in all areas. */
     travelMode?: "car" | "truck" | "taxi" | "bus" | "van" | "motorcycle" | "bicycle" | "pedestrian";
     /** Degree of hilliness for thrilling route. This parameter can only be used in conjunction with `routeType`=thrilling. */
     hilliness?: "low" | "normal" | "high";
@@ -1851,7 +2024,7 @@ export declare interface RouteGetRouteRangeQueryParamProperties {
     vehicleWeight?: number;
     /** Whether the vehicle is used for commercial purposes. Commercial vehicles may not be allowed to drive on some roads. */
     vehicleCommercial?: boolean;
-    /** Types of cargo that may be classified as hazardous materials and restricted from some roads. Available vehicleLoadType values are US Hazmat classes 1 through 9, plus generic classifications for use in other countries. Values beginning with USHazmat are for US routing while otherHazmat should be used for all other countries. vehicleLoadType can be specified multiple times. This parameter is currently only considered for travelMode=truck. */
+    /** Types of cargo that may be classified as hazardous materials and restricted from some roads. Available vehicleLoadType values are US Hazmat classes 1 through 9, plus generic classifications for use in other countries/regions. Values beginning with USHazmat are for US routing while otherHazmat should be used for all other countries/regions. vehicleLoadType can be specified multiple times. This parameter is currently only considered for travelMode=truck. */
     vehicleLoadType?: "USHazmatClass1" | "USHazmatClass2" | "USHazmatClass3" | "USHazmatClass4" | "USHazmatClass5" | "USHazmatClass6" | "USHazmatClass7" | "USHazmatClass8" | "USHazmatClass9" | "otherHazmatExplosive" | "otherHazmatGeneral" | "otherHazmatHarmfulToWater";
     /** Engine type of the vehicle. When a detailed Consumption Model is specified, it must be consistent with the value of **vehicleEngineType**. */
     vehicleEngineType?: "combustion" | "electric";
@@ -1995,49 +2168,49 @@ export declare interface RouteGetRouteRangeQueryParamProperties {
 /** Contains guidance related elements. This field is present only when guidance was requested and is available. */
 export declare interface RouteGuidanceOutput {
     /** A list of instructions describing maneuvers. */
-    instructions: Array<RouteInstructionOutput>;
+    readonly instructions: Array<RouteInstructionOutput>;
     /** Groups a sequence of instruction elements which are related to each other. */
-    instructionGroups: Array<RouteInstructionGroupOutput>;
+    readonly instructionGroups: Array<RouteInstructionGroupOutput>;
 }
 
 /** Groups a sequence of instruction elements which are related to each other. The sequence range is constrained with firstInstructionIndex and lastInstructionIndex. When human-readable text messages are requested for guidance (instructionType=text or tagged), then the instructionGroup has a summary message returned when available. */
 export declare interface RouteInstructionGroupOutput {
     /** Index of the first instruction in the instructions and belonging to this group. */
-    firstInstructionIndex?: number;
+    readonly firstInstructionIndex?: number;
     /** Index of the last instruction in the instructions and belonging to this group. */
-    lastInstructionIndex?: number;
+    readonly lastInstructionIndex?: number;
     /** Length of the group. */
-    groupLengthInMeters?: number;
+    readonly groupLengthInMeters?: number;
     /** Summary message when human-readable text messages are requested for guidance (instructionType=text or tagged). */
-    groupMessage?: string;
+    readonly groupMessage?: string;
 }
 
 /** A set of attributes describing a maneuver, e.g. 'Turn right', 'Keep left', 'Take the ferry', 'Take the motorway', 'Arrive'. */
 export declare interface RouteInstructionOutput {
     /** Distance from the start of the route to the point of the instruction. */
-    routeOffsetInMeters?: number;
+    readonly routeOffsetInMeters?: number;
     /** Estimated travel time up to the point corresponding to routeOffsetInMeters. */
-    travelTimeInSeconds?: number;
+    readonly travelTimeInSeconds?: number;
     /** A location represented as a latitude and longitude. */
     point?: LatLongPairOutput;
     /** The index of the point in the list of polyline "points" corresponding to the point of the instruction. */
-    pointIndex?: number;
+    readonly pointIndex?: number;
     /** Type of the instruction, e.g., turn or change of road form. */
     instructionType?: "TURN" | "ROAD_CHANGE" | "LOCATION_DEPARTURE" | "LOCATION_ARRIVAL" | "DIRECTION_INFO" | "LOCATION_WAYPOINT";
     /** The road number(s) of the next significant road segment(s) after the maneuver, or of the road(s) to be followed. Example: ["E34", "N205"] */
-    roadNumbers?: Array<string>;
+    readonly roadNumbers?: Array<string>;
     /** The number(s) of a highway exit taken by the current maneuver. If an exit has multiple exit numbers, they will be separated by "," and possibly aggregated by "-", e.g., "10, 13-15". */
-    exitNumber?: string;
+    readonly exitNumber?: string;
     /** Street name of the next significant road segment after the maneuver, or of the street that should be followed. */
-    street?: string;
+    readonly street?: string;
     /** The text on a signpost which is most relevant to the maneuver, or to the direction that should be followed. */
-    signpostText?: string;
+    readonly signpostText?: string;
     /** 3-character [ISO 3166-1](https://www.iso.org/iso-3166-country-codes.html) alpha-3 country code. E.g. USA. */
-    countryCode?: string;
-    /** A subdivision (e.g., state) of the country, represented by the second part of an [ISO 3166-2](https://www.iso.org/standard/63546.html) code. This is only available for some countries like the US, Canada, and Mexico. */
-    stateCode?: string;
+    readonly countryCode?: string;
+    /** A subdivision (e.g., state) of the country, represented by the second part of an [ISO 3166-2](https://www.iso.org/standard/63546.html) code. This is only available for some countries/regions like the US, Canada, and Mexico. */
+    readonly stateCode?: string;
     /** The type of the junction where the maneuver takes place. For larger roundabouts, two separate instructions are generated for entering and leaving the roundabout. */
-    junctionType?: "REGULAR" | "ROUNDABOUT" | "BIFURCATION";
+    readonly junctionType?: "REGULAR" | "ROUNDABOUT" | "BIFURCATION";
     /**
      * Indicates the direction of an instruction. If junctionType indicates a turn instruction:
      *
@@ -2051,17 +2224,17 @@ export declare interface RouteInstructionOutput {
      *   * <0 - keep left
      *   * \>0 - keep right
      */
-    turnAngleInDecimalDegrees?: number;
+    readonly turnAngleInDecimalDegrees?: number;
     /** This indicates which exit to take at a roundabout. */
-    roundaboutExitNumber?: string;
+    readonly roundaboutExitNumber?: number;
     /** It is possible to optionally combine the instruction with the next one. This can be used to build messages like "Turn left and then turn right". */
-    possibleCombineWithNext?: boolean;
+    readonly possibleCombineWithNext?: boolean;
     /** Indicates left-hand vs. right-hand side driving at the point of the maneuver. */
-    drivingSide?: "LEFT" | "RIGHT";
+    readonly drivingSide?: "LEFT" | "RIGHT";
     /** A code identifying the maneuver. */
-    maneuver?: "ARRIVE" | "ARRIVE_LEFT" | "ARRIVE_RIGHT" | "DEPART" | "STRAIGHT" | "KEEP_RIGHT" | "BEAR_RIGHT" | "TURN_RIGHT" | "SHARP_RIGHT" | "KEEP_LEFT" | "BEAR_LEFT" | "TURN_LEFT" | "SHARP_LEFT" | "MAKE_UTURN" | "ENTER_MOTORWAY" | "ENTER_FREEWAY" | "ENTER_HIGHWAY" | "TAKE_EXIT" | "MOTORWAY_EXIT_LEFT" | "MOTORWAY_EXIT_RIGHT" | "TAKE_FERRY" | "ROUNDABOUT_CROSS" | "ROUNDABOUT_RIGHT" | "ROUNDABOUT_LEFT" | "ROUNDABOUT_BACK" | "TRY_MAKE_UTURN" | "FOLLOW" | "SWITCH_PARALLEL_ROAD" | "SWITCH_MAIN_ROAD" | "ENTRANCE_RAMP" | "WAYPOINT_LEFT" | "WAYPOINT_RIGHT" | "WAYPOINT_REACHED";
+    readonly maneuver?: "ARRIVE" | "ARRIVE_LEFT" | "ARRIVE_RIGHT" | "DEPART" | "STRAIGHT" | "KEEP_RIGHT" | "BEAR_RIGHT" | "TURN_RIGHT" | "SHARP_RIGHT" | "KEEP_LEFT" | "BEAR_LEFT" | "TURN_LEFT" | "SHARP_LEFT" | "MAKE_UTURN" | "ENTER_MOTORWAY" | "ENTER_FREEWAY" | "ENTER_HIGHWAY" | "TAKE_EXIT" | "MOTORWAY_EXIT_LEFT" | "MOTORWAY_EXIT_RIGHT" | "TAKE_FERRY" | "ROUNDABOUT_CROSS" | "ROUNDABOUT_RIGHT" | "ROUNDABOUT_LEFT" | "ROUNDABOUT_BACK" | "TRY_MAKE_UTURN" | "FOLLOW" | "SWITCH_PARALLEL_ROAD" | "SWITCH_MAIN_ROAD" | "ENTRANCE_RAMP" | "WAYPOINT_LEFT" | "WAYPOINT_RIGHT" | "WAYPOINT_REACHED";
     /** A human-readable message for the maneuver. */
-    message?: string;
+    readonly message?: string;
     /**
      * A human-readable message for the maneuver combined with the message from the next instruction. Sometimes it is possible to combine two successive instructions into a single instruction making it easier to follow. When this is the case the possibleCombineWithNext flag will be true. For example:
      *
@@ -2077,23 +2250,23 @@ export declare interface RouteInstructionOutput {
      * then follow Einsteinweg/A10/E22 towards Ring Amsterdam.
      * ```
      */
-    combinedMessage?: string;
+    readonly combinedMessage?: string;
 }
 
 /** A description of a part of a route, comprised of a list of points. Each additional waypoint provided in the request will result in an additional leg in the returned route. */
 export declare interface RouteLegOutput {
     /** Summary object */
-    summary: RouteSummaryOutput;
+    readonly summary: RouteSummaryOutput;
     /** Points array */
-    points: Array<LatLongPairOutput>;
+    readonly points: Array<LatLongPairOutput>;
 }
 
 /** Matrix result object */
 export declare interface RouteMatrixOutput {
     /** StatusCode property for the current cell in the input matrix. */
-    statusCode: number;
+    readonly statusCode: number;
     /** Response object of the current cell in the input matrix. */
-    response?: RouteMatrixResultResponseOutput;
+    readonly response?: RouteMatrixResultResponseOutput;
 }
 
 /** An object with a matrix of coordinates. */
@@ -2107,44 +2280,44 @@ export declare interface RouteMatrixQuery {
 /** This object is returned from a successful Route Matrix call. For ex, if 2 origins and 3 destinations are provided, there are going to 2 arrays with 3 elements in each. Each element's content depends on the options provided in the query. */
 export declare interface RouteMatrixResultOutput {
     /** Format Version property */
-    formatVersion?: string;
+    readonly formatVersion?: string;
     /** Results as a 2 dimensional array of route summaries. */
-    matrix: Array<Array<RouteMatrixOutput>>;
+    readonly matrix: Array<Array<RouteMatrixOutput>>;
     /** Summary object */
-    summary: RouteMatrixSummaryOutput;
+    readonly summary: RouteMatrixSummaryOutput;
 }
 
 /** Response object of the current cell in the input matrix. */
 export declare interface RouteMatrixResultResponseOutput {
     /** Summary object */
-    routeSummary?: RouteSummaryOutput;
+    readonly routeSummary?: RouteSummaryOutput;
 }
 
 /** Summary object */
 export declare interface RouteMatrixSummaryOutput {
     /** Number of successful routes in the response. */
-    successfulRoutes: number;
+    readonly successfulRoutes: number;
     /** Total number of routes requested. Number of cells in the input matrix. */
-    totalRoutes: number;
+    readonly totalRoutes: number;
 }
 
 /** Optimized way point object. */
 export declare interface RouteOptimizedWaypointOutput {
     /** Way point index provided by the user. */
-    providedIndex: number;
+    readonly providedIndex: number;
     /** Optimized way point index from the system. */
-    optimizedIndex: number;
+    readonly optimizedIndex: number;
 }
 
 export declare interface RouteOutput {
     /** Summary object */
-    summary: RouteSummaryOutput;
+    readonly summary: RouteSummaryOutput;
     /** Legs array */
-    legs: Array<RouteLegOutput>;
+    readonly legs: Array<RouteLegOutput>;
     /** Sections array */
-    sections?: Array<RouteSectionOutput>;
+    readonly sections?: Array<RouteSectionOutput>;
     /** Contains guidance related elements. This field is present only when guidance was requested and is available. */
-    guidance?: RouteGuidanceOutput;
+    readonly guidance?: RouteGuidanceOutput;
 }
 
 /** Reachable Range */
@@ -2152,13 +2325,13 @@ export declare interface RouteRangeOutput {
     /** Center point of the reachable range */
     center: LatLongPairOutput;
     /** Polygon boundary of the reachable range represented as a list of points. */
-    boundary: Array<LatLongPairOutput>;
+    readonly boundary: Array<LatLongPairOutput>;
 }
 
 /** This object is returned from a successful Route Reachable Range call */
 export declare interface RouteRangeResultOutput {
     /** Format Version property */
-    formatVersion?: string;
+    readonly formatVersion?: string;
     /** Reachable Range */
     reachableRange: RouteRangeOutput;
     /** Reports the effective settings used in the current call. */
@@ -2168,18 +2341,13 @@ export declare interface RouteRangeResultOutput {
 /** Reports the effective settings used in the current call. */
 export declare interface RouteReportOutput {
     /** Effective parameters or data used when calling this Route API. */
-    effectiveSettings: Array<EffectiveSettingOutput>;
+    readonly effectiveSettings: Array<EffectiveSettingOutput>;
 }
 
 /**
- * **Route Directions Batch API**
  *
+ * The `Post Route Directions Batch` API is an HTTP `POST` request that sends batches of queries to the [Get Route Directions](/rest/api/maps/route/get-route-directions) API using a single asynchronous request. You can call `Route Directions Batch` API to run either asynchronously (async) or synchronously (sync). The async API allows caller to batch up to **700** queries and sync API up to **100** queries. To call the `Post Route Directions Batch` API in a synchronous request, see [Post Route Directions Batch Sync](/rest/api/maps/route/post-route-directions-batch-sync).
  *
- * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
- *
- *
- *
- * The Route Directions Batch API sends batches of queries to [Route Directions API](https://docs.microsoft.com/rest/api/maps/route/getroutedirections) using just a single API call. You can call Route Directions Batch API to run either asynchronously (async) or synchronously (sync). The async API allows caller to batch up to **700** queries and sync API up to **100** queries.
  * ### Submit Asynchronous Batch Request
  * The Asynchronous API is appropriate for processing big volumes of relatively complex route requests
  * - It allows the retrieval of results in a separate call (multiple downloads are possible).
@@ -2187,10 +2355,13 @@ export declare interface RouteReportOutput {
  * - The number of batch items is limited to **700** for this API.
  *
  * When you make a request by using async request, by default the service returns a 202 response code along a redirect URL in the Location field of the response header. This URL should be checked periodically until the response data or error information is available.
- * The asynchronous responses are stored for **14** days. The redirect URL returns a 404 response if used after the expiration period.
+ * The asynchronous responses are stored for **24** hours. The redirect URL returns a 404 response if used after the expiration period.
  *
- * Please note that asynchronous batch request is a long-running request. Here's a typical sequence of operations:
- * 1. Client sends a Route Directions Batch `POST` request to Azure Maps
+ * Please note that asynchronous batch request is a long-running operation. Here's a typical sequence of operations:
+ * 1. Client sends a Route Directions Batch `POST` request to Azure Maps.
+ * ```
+ * POST https://atlas.microsoft.com/route/directions/batch/json?api-version=1.0&subscription-key={subscription-key}
+ * ```
  * 2. The server will respond with one of the following:
  *
  *     > HTTP `202 Accepted` - Batch request has been accepted.
@@ -2199,9 +2370,9 @@ export declare interface RouteReportOutput {
  *
  * 3. If the batch request was accepted successfully, the `Location` header in the response contains the URL to download the results of the batch request.
  *     This status URI looks like following:
- *
- * ``` GET https://atlas.microsoft.com/route/directions/batch/{batch-id}?api-version=1.0 ```
- * Note:- Please remember to add AUTH information (subscription-key/azure_auth - See [Security](#security)) to the _status URI_ before running it. <br>
+ * ```
+ * GET https://atlas.microsoft.com/route/directions/batch/{batch-id}?api-version=1.0&subscription-key={subscription-key}
+ * ```
  * 4. Client issues a `GET` request on the _download URL_ obtained in Step 3 to download the batch results.
  *
  * ### POST Body for Batch Request
@@ -2328,19 +2499,14 @@ export declare interface RouteRequestRouteDirectionsBatch200Response extends Htt
 }
 
 export declare interface RouteRequestRouteDirectionsBatch202Headers {
-    /** New URL to check for the results of the long running process. */
+    /** New URL to check for the results of the long-running operation. */
     location?: string;
 }
 
 /**
- * **Route Directions Batch API**
  *
+ * The `Post Route Directions Batch` API is an HTTP `POST` request that sends batches of queries to the [Get Route Directions](/rest/api/maps/route/get-route-directions) API using a single asynchronous request. You can call `Route Directions Batch` API to run either asynchronously (async) or synchronously (sync). The async API allows caller to batch up to **700** queries and sync API up to **100** queries. To call the `Post Route Directions Batch` API in a synchronous request, see [Post Route Directions Batch Sync](/rest/api/maps/route/post-route-directions-batch-sync).
  *
- * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
- *
- *
- *
- * The Route Directions Batch API sends batches of queries to [Route Directions API](https://docs.microsoft.com/rest/api/maps/route/getroutedirections) using just a single API call. You can call Route Directions Batch API to run either asynchronously (async) or synchronously (sync). The async API allows caller to batch up to **700** queries and sync API up to **100** queries.
  * ### Submit Asynchronous Batch Request
  * The Asynchronous API is appropriate for processing big volumes of relatively complex route requests
  * - It allows the retrieval of results in a separate call (multiple downloads are possible).
@@ -2348,10 +2514,13 @@ export declare interface RouteRequestRouteDirectionsBatch202Headers {
  * - The number of batch items is limited to **700** for this API.
  *
  * When you make a request by using async request, by default the service returns a 202 response code along a redirect URL in the Location field of the response header. This URL should be checked periodically until the response data or error information is available.
- * The asynchronous responses are stored for **14** days. The redirect URL returns a 404 response if used after the expiration period.
+ * The asynchronous responses are stored for **24** hours. The redirect URL returns a 404 response if used after the expiration period.
  *
- * Please note that asynchronous batch request is a long-running request. Here's a typical sequence of operations:
- * 1. Client sends a Route Directions Batch `POST` request to Azure Maps
+ * Please note that asynchronous batch request is a long-running operation. Here's a typical sequence of operations:
+ * 1. Client sends a Route Directions Batch `POST` request to Azure Maps.
+ * ```
+ * POST https://atlas.microsoft.com/route/directions/batch/json?api-version=1.0&subscription-key={subscription-key}
+ * ```
  * 2. The server will respond with one of the following:
  *
  *     > HTTP `202 Accepted` - Batch request has been accepted.
@@ -2360,9 +2529,9 @@ export declare interface RouteRequestRouteDirectionsBatch202Headers {
  *
  * 3. If the batch request was accepted successfully, the `Location` header in the response contains the URL to download the results of the batch request.
  *     This status URI looks like following:
- *
- * ``` GET https://atlas.microsoft.com/route/directions/batch/{batch-id}?api-version=1.0 ```
- * Note:- Please remember to add AUTH information (subscription-key/azure_auth - See [Security](#security)) to the _status URI_ before running it. <br>
+ * ```
+ * GET https://atlas.microsoft.com/route/directions/batch/{batch-id}?api-version=1.0&subscription-key={subscription-key}
+ * ```
  * 4. Client issues a `GET` request on the _download URL_ obtained in Step 3 to download the batch results.
  *
  * ### POST Body for Batch Request
@@ -2485,7 +2654,6 @@ export declare interface RouteRequestRouteDirectionsBatch202Headers {
  */
 export declare interface RouteRequestRouteDirectionsBatch202Response extends HttpResponse {
     status: "202";
-    body: Record<string, unknown>;
     headers: RawHttpHeaders & RouteRequestRouteDirectionsBatch202Headers;
 }
 
@@ -2502,14 +2670,8 @@ export declare interface RouteRequestRouteDirectionsBatchMediaTypesParam {
 export declare type RouteRequestRouteDirectionsBatchParameters = RouteRequestRouteDirectionsBatchMediaTypesParam & RouteRequestRouteDirectionsBatchBodyParam & RequestParameters;
 
 /**
- * **Route Directions Batch API**
- *
  *
- * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
- *
- *
- *
- * The Route Directions Batch API sends batches of queries to [Route Directions API](https://docs.microsoft.com/rest/api/maps/route/getroutedirections) using just a single API call. You can call Route Directions Batch API to run either asynchronously (async) or synchronously (sync). The async API allows caller to batch up to **700** queries and sync API up to **100** queries.
+ * The `Post Route Directions Batch Sync` API is an HTTP `POST` request that sends batches of queries to the [Get Route Directions](/rest/api/maps/route/get-route-directions) API using a single synchronous request. You can call `Route Directions Batch` API to run either asynchronously (async) or synchronously (sync). The async API allows caller to batch up to **700** queries and sync API up to **100** queries. To call the `Post Route Directions Batch` API in a asynchronous request, see [Post Route Directions Batch](/rest/api/maps/route/post-route-directions-batch).
  * ### 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.
  * ```
@@ -2603,14 +2765,8 @@ export declare interface RouteRequestRouteDirectionsBatchSync200Response extends
 }
 
 /**
- * **Route Directions Batch API**
- *
  *
- * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
- *
- *
- *
- * The Route Directions Batch API sends batches of queries to [Route Directions API](https://docs.microsoft.com/rest/api/maps/route/getroutedirections) using just a single API call. You can call Route Directions Batch API to run either asynchronously (async) or synchronously (sync). The async API allows caller to batch up to **700** queries and sync API up to **100** queries.
+ * The `Post Route Directions Batch Sync` API is an HTTP `POST` request that sends batches of queries to the [Get Route Directions](/rest/api/maps/route/get-route-directions) API using a single synchronous request. You can call `Route Directions Batch` API to run either asynchronously (async) or synchronously (sync). The async API allows caller to batch up to **700** queries and sync API up to **100** queries. To call the `Post Route Directions Batch` API in a asynchronous request, see [Post Route Directions Batch](/rest/api/maps/route/post-route-directions-batch).
  * ### 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.
  * ```
@@ -2709,14 +2865,8 @@ export declare interface RouteRequestRouteDirectionsBatchSyncBodyParam {
 }
 
 /**
- * **Route Directions Batch API**
- *
  *
- * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
- *
- *
- *
- * The Route Directions Batch API sends batches of queries to [Route Directions API](https://docs.microsoft.com/rest/api/maps/route/getroutedirections) using just a single API call. You can call Route Directions Batch API to run either asynchronously (async) or synchronously (sync). The async API allows caller to batch up to **700** queries and sync API up to **100** queries.
+ * The `Post Route Directions Batch Sync` API is an HTTP `POST` request that sends batches of queries to the [Get Route Directions](/rest/api/maps/route/get-route-directions) API using a single synchronous request. You can call `Route Directions Batch` API to run either asynchronously (async) or synchronously (sync). The async API allows caller to batch up to **700** queries and sync API up to **100** queries. To call the `Post Route Directions Batch` API in a asynchronous request, see [Post Route Directions Batch](/rest/api/maps/route/post-route-directions-batch).
  * ### 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.
  * ```
@@ -2818,9 +2968,7 @@ export declare type RouteRequestRouteDirectionsBatchSyncParameters = RouteReques
 
 /**
  *
- * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
- *
- * The Matrix Routing service allows calculation of a matrix of route summaries for a set of routes defined by origin and destination locations by using an asynchronous (async) or synchronous (sync) POST request. For every given origin, the service calculates the cost of routing from that origin to every given destination. The set of origins and the set of destinations can be thought of as the column and row headers of a table and each cell in the table contains the costs of routing from the origin to the destination for that cell. As an example, let's say a food delivery company has 20 drivers and they need to find the closest driver to pick up the delivery from the restaurant. To solve this use case, they can call Matrix Route API.
+ * The `Post Route Matrix` API is an HTTP `POST` request that allows calculation of a matrix of route summaries for a set of routes defined by origin and destination locations by using an asynchronous (async) request. To make a synchronous (sync) request, see [Post Route Matrix Sync](/rest/api/maps/route/post-route-matrix-sync). For every given origin, the service calculates the cost of routing from that origin to every given destination. The set of origins and the set of destinations can be thought of as the column and row headers of a table and each cell in the table contains the costs of routing from the origin to the destination for that cell. As an example, let's say a food delivery company has 20 drivers and they need to find the closest driver to pick up the delivery from the restaurant. To solve this use case, they can call Matrix Route API.
  *
  *
  * For each route, the travel times and distances are returned. You can use the computed costs to determine which detailed routes to calculate using the Route Directions API.
@@ -2828,6 +2976,9 @@ export declare type RouteRequestRouteDirectionsBatchSyncParameters = RouteReques
  *
  * The maximum size of a matrix for async request is **700** and for sync request it's **100** (the number of origins multiplied by the number of destinations).
  *
+ * > [!NOTE]
+ * > All origins and destinations should be contained in an axis-aligned 400 km x 400 km bounding box. Otherwise some matrix cells will be resolved as OUT_OF_REGION.
+ *
  *
  *
  * ### Submit Synchronous Route Matrix Request
@@ -2844,7 +2995,7 @@ export declare type RouteRequestRouteDirectionsBatchSyncParameters = RouteReques
  * The maximum size of a matrix for this API is **700** (the number of origins multiplied by the number of destinations). With that constraint in mind, examples of possible matrix dimensions are: 50x10, 10x10, 28x25. 10x70 (it does not need to be square).
  *
  *
- * The asynchronous responses are stored for **14** days. The redirect URL returns a 404 response if used after the expiration period.
+ * The asynchronous responses are stored for **24** hours. The redirect URL returns a 404 response if used after the expiration period.
  *
  *
  *
@@ -2893,15 +3044,13 @@ export declare interface RouteRequestRouteMatrix200Response extends HttpResponse
 }
 
 export declare interface RouteRequestRouteMatrix202Headers {
-    /** New URL to check for the results of the long running process. */
+    /** New URL to check for the results of the long-running operation. */
     location?: string;
 }
 
 /**
  *
- * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
- *
- * The Matrix Routing service allows calculation of a matrix of route summaries for a set of routes defined by origin and destination locations by using an asynchronous (async) or synchronous (sync) POST request. For every given origin, the service calculates the cost of routing from that origin to every given destination. The set of origins and the set of destinations can be thought of as the column and row headers of a table and each cell in the table contains the costs of routing from the origin to the destination for that cell. As an example, let's say a food delivery company has 20 drivers and they need to find the closest driver to pick up the delivery from the restaurant. To solve this use case, they can call Matrix Route API.
+ * The `Post Route Matrix` API is an HTTP `POST` request that allows calculation of a matrix of route summaries for a set of routes defined by origin and destination locations by using an asynchronous (async) request. To make a synchronous (sync) request, see [Post Route Matrix Sync](/rest/api/maps/route/post-route-matrix-sync). For every given origin, the service calculates the cost of routing from that origin to every given destination. The set of origins and the set of destinations can be thought of as the column and row headers of a table and each cell in the table contains the costs of routing from the origin to the destination for that cell. As an example, let's say a food delivery company has 20 drivers and they need to find the closest driver to pick up the delivery from the restaurant. To solve this use case, they can call Matrix Route API.
  *
  *
  * For each route, the travel times and distances are returned. You can use the computed costs to determine which detailed routes to calculate using the Route Directions API.
@@ -2909,6 +3058,9 @@ export declare interface RouteRequestRouteMatrix202Headers {
  *
  * The maximum size of a matrix for async request is **700** and for sync request it's **100** (the number of origins multiplied by the number of destinations).
  *
+ * > [!NOTE]
+ * > All origins and destinations should be contained in an axis-aligned 400 km x 400 km bounding box. Otherwise some matrix cells will be resolved as OUT_OF_REGION.
+ *
  *
  *
  * ### Submit Synchronous Route Matrix Request
@@ -2925,7 +3077,7 @@ export declare interface RouteRequestRouteMatrix202Headers {
  * The maximum size of a matrix for this API is **700** (the number of origins multiplied by the number of destinations). With that constraint in mind, examples of possible matrix dimensions are: 50x10, 10x10, 28x25. 10x70 (it does not need to be square).
  *
  *
- * The asynchronous responses are stored for **14** days. The redirect URL returns a 404 response if used after the expiration period.
+ * The asynchronous responses are stored for **24** hours. The redirect URL returns a 404 response if used after the expiration period.
  *
  *
  *
@@ -2970,7 +3122,6 @@ export declare interface RouteRequestRouteMatrix202Headers {
  */
 export declare interface RouteRequestRouteMatrix202Response extends HttpResponse {
     status: "202";
-    body: Record<string, unknown>;
     headers: RawHttpHeaders & RouteRequestRouteMatrix202Headers;
 }
 
@@ -2995,11 +3146,29 @@ export declare interface RouteRequestRouteMatrixQueryParamProperties {
     waitForResults?: boolean;
     /** Specifies whether to return additional travel times using different types of traffic information (none, historic, live) as well as the default best-estimate travel time. */
     computeTravelTimeFor?: "none" | "all";
-    /** Specifies which of the section types is reported in the route response. <br><br>For example if sectionType = pedestrian the sections which are suited for pedestrians only are returned. Multiple types can be used. The default sectionType refers to the travelMode input. By default travelMode is set to car */
-    sectionType?: "carTrain" | "country" | "ferry" | "motorway" | "pedestrian" | "tollRoad" | "tollVignette" | "traffic" | "travelMode" | "tunnel" | "carpool" | "urban";
-    /** The date and time of arrival at the destination point. It must be specified as a dateTime. When a time zone offset is not specified it will be assumed to be that of the destination point. The arriveAt value must be in the future. The arriveAt parameter cannot be used in conjunction with departAt, minDeviationDistance or minDeviationTime. */
+    /** Specifies which of the section types is reported in the route response. <br><br>For example if sectionType = pedestrian the sections which are suited for pedestrians only are returned. Can be specified multiple times in one request, for example, '&sectionType=carTrain&sectionType=pedestrian&sectionType=motorway'. The default sectionType refers to the travelMode input. By default travelMode is set to car */
+    sectionType?: Array<"carTrain" | "country" | "ferry" | "motorway" | "pedestrian" | "tollRoad" | "tollVignette" | "traffic" | "travelMode" | "tunnel" | "carpool" | "urban">;
+    /**
+     * The date and time of arrival at the destination point formatted as a `dateTime` value as defined in [RFC 3339, section 5.6](https://www.rfc-editor.org/rfc/rfc3339#section-5.6), with an optional time zone offset. When a time zone offset is not specified it will be assumed to be that of the destination point.
+     *
+     * Examples:
+     *   * 2023-12-19T16:39:57
+     *   * 2023-12-19T16:39:57-08:00
+     *
+     * The `arriveAt` parameter cannot be used in conjunction with `departAt`, `minDeviationDistance` or `minDeviationTime`.
+     */
     arriveAt?: Date | string;
-    /** The date and time of departure from the origin point. Departure times apart from now must be specified as a dateTime. When a time zone offset is not specified, it will be assumed to be that of the origin point. The departAt value must be in the future in the date-time format (1996-12-19T16:39:57-08:00). */
+    /**
+     * The date and time of departure from the origin point formatted as a `dateTime` value as defined in [RFC 3339, section 5.6](https://www.rfc-editor.org/rfc/rfc3339#section-5.6), with an optional time zone offset. When a time zone offset is not specified, it will be assumed to be that of the origin point.
+     *   * Default value: now
+     *   * Other value: `dateTime`
+     *
+     * Examples:
+     *   * 2023-12-19T16:39:57
+     *   * 2023-12-19T16:39:57-08:00
+     *
+     * The `departAt` parameter cannot be used in conjunction with `arriveAt`.
+     */
     departAt?: Date | string;
     /** Weight per axle of the vehicle in kg. A value of 0 means that weight restrictions per axle are not considered. */
     vehicleAxleWeight?: number;
@@ -3023,9 +3192,9 @@ export declare interface RouteRequestRouteMatrixQueryParamProperties {
     windingness?: "low" | "normal" | "high";
     /** Degree of hilliness for thrilling route. This parameter can only be used in conjunction with `routeType`=thrilling. */
     hilliness?: "low" | "normal" | "high";
-    /** The mode of travel for the requested route. If not defined, default is 'car'. Note that the requested travelMode may not be available for the entire route. Where the requested travelMode is not available for a particular section, the travelMode element of the response for that section will be "other". Note that travel modes bus, motorcycle, taxi and van are BETA functionality. Full restriction data is not available in all areas. In **calculateReachableRange** requests, the values bicycle and pedestrian must not be used. */
+    /** The mode of travel for the requested route. If not defined, default is 'car'. Note that the requested travelMode may not be available for the entire route. Where the requested travelMode is not available for a particular section, the travelMode element of the response for that section will be "other". Note that travel modes bus, motorcycle, taxi and van are BETA functionality. Full restriction data is not available in all areas. */
     travelMode?: "car" | "truck" | "taxi" | "bus" | "van" | "motorcycle" | "bicycle" | "pedestrian";
-    /** Specifies something that the route calculation should try to avoid when determining the route. Can be specified multiple times in one request, for example, '&avoid=motorways&avoid=tollRoads&avoid=ferries'. In calculateReachableRange requests, the value alreadyUsedRoads must not be used. */
+    /** Specifies something that the route calculation should try to avoid when determining the route. Can be specified multiple times in one request, for example, '&avoid=motorways&avoid=tollRoads&avoid=ferries'. In Route Range requests, the value alreadyUsedRoads must not be used. */
     avoid?: Array<"tollRoads" | "motorways" | "ferries" | "unpavedRoads" | "carpools" | "alreadyUsedRoads" | "borderCrossings">;
     /**
      * Possible values:
@@ -3036,15 +3205,13 @@ export declare interface RouteRequestRouteMatrixQueryParamProperties {
     traffic?: boolean;
     /** The type of route requested. */
     routeType?: "fastest" | "shortest" | "eco" | "thrilling";
-    /** Types of cargo that may be classified as hazardous materials and restricted from some roads. Available vehicleLoadType values are US Hazmat classes 1 through 9, plus generic classifications for use in other countries. Values beginning with USHazmat are for US routing while otherHazmat should be used for all other countries. vehicleLoadType can be specified multiple times. This parameter is currently only considered for travelMode=truck. */
+    /** Types of cargo that may be classified as hazardous materials and restricted from some roads. Available vehicleLoadType values are US Hazmat classes 1 through 9, plus generic classifications for use in other countries/regions. Values beginning with USHazmat are for US routing while otherHazmat should be used for all other countries/regions. vehicleLoadType can be specified multiple times. This parameter is currently only considered for travelMode=truck. */
     vehicleLoadType?: "USHazmatClass1" | "USHazmatClass2" | "USHazmatClass3" | "USHazmatClass4" | "USHazmatClass5" | "USHazmatClass6" | "USHazmatClass7" | "USHazmatClass8" | "USHazmatClass9" | "otherHazmatExplosive" | "otherHazmatGeneral" | "otherHazmatHarmfulToWater";
 }
 
 /**
  *
- * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
- *
- * The Matrix Routing service allows calculation of a matrix of route summaries for a set of routes defined by origin and destination locations by using an asynchronous (async) or synchronous (sync) POST request. For every given origin, the service calculates the cost of routing from that origin to every given destination. The set of origins and the set of destinations can be thought of as the column and row headers of a table and each cell in the table contains the costs of routing from the origin to the destination for that cell. As an example, let's say a food delivery company has 20 drivers and they need to find the closest driver to pick up the delivery from the restaurant. To solve this use case, they can call Matrix Route API.
+ * The `Post Route Matrix Sync` API is an HTTP `POST` request that allows calculation of a matrix of route summaries for a set of routes defined by origin and destination locations by using a single synchronous (sync) request. To make an asynchronous (async) request, see [Post Route Matrix](/rest/api/maps/route/post-route-matrix). For every given origin, the service calculates the cost of routing from that origin to every given destination. The set of origins and the set of destinations can be thought of as the column and row headers of a table and each cell in the table contains the costs of routing from the origin to the destination for that cell. As an example, let's say a food delivery company has 20 drivers and they need to find the closest driver to pick up the delivery from the restaurant. To solve this use case, they can call Matrix Route API.
  *
  *
  * For each route, the travel times and distances are returned. You can use the computed costs to determine which detailed routes to calculate using the Route Directions API.
@@ -3068,7 +3235,7 @@ export declare interface RouteRequestRouteMatrixQueryParamProperties {
  * The maximum size of a matrix for this API is **700** (the number of origins multiplied by the number of destinations). With that constraint in mind, examples of possible matrix dimensions are: 50x10, 10x10, 28x25. 10x70 (it does not need to be square).
  *
  *
- * The asynchronous responses are stored for **14** days. The redirect URL returns a 404 response if used after the expiration period.
+ * The asynchronous responses are stored for **24** hours. The redirect URL returns a 404 response if used after the expiration period.
  *
  *
  *
@@ -3118,9 +3285,7 @@ export declare interface RouteRequestRouteMatrixSync200Response extends HttpResp
 
 /**
  *
- * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
- *
- * The Matrix Routing service allows calculation of a matrix of route summaries for a set of routes defined by origin and destination locations by using an asynchronous (async) or synchronous (sync) POST request. For every given origin, the service calculates the cost of routing from that origin to every given destination. The set of origins and the set of destinations can be thought of as the column and row headers of a table and each cell in the table contains the costs of routing from the origin to the destination for that cell. As an example, let's say a food delivery company has 20 drivers and they need to find the closest driver to pick up the delivery from the restaurant. To solve this use case, they can call Matrix Route API.
+ * The `Post Route Matrix Sync` API is an HTTP `POST` request that allows calculation of a matrix of route summaries for a set of routes defined by origin and destination locations by using a single synchronous (sync) request. To make an asynchronous (async) request, see [Post Route Matrix](/rest/api/maps/route/post-route-matrix). For every given origin, the service calculates the cost of routing from that origin to every given destination. The set of origins and the set of destinations can be thought of as the column and row headers of a table and each cell in the table contains the costs of routing from the origin to the destination for that cell. As an example, let's say a food delivery company has 20 drivers and they need to find the closest driver to pick up the delivery from the restaurant. To solve this use case, they can call Matrix Route API.
  *
  *
  * For each route, the travel times and distances are returned. You can use the computed costs to determine which detailed routes to calculate using the Route Directions API.
@@ -3144,7 +3309,7 @@ export declare interface RouteRequestRouteMatrixSync200Response extends HttpResp
  * The maximum size of a matrix for this API is **700** (the number of origins multiplied by the number of destinations). With that constraint in mind, examples of possible matrix dimensions are: 50x10, 10x10, 28x25. 10x70 (it does not need to be square).
  *
  *
- * The asynchronous responses are stored for **14** days. The redirect URL returns a 404 response if used after the expiration period.
+ * The asynchronous responses are stored for **24** hours. The redirect URL returns a 404 response if used after the expiration period.
  *
  *
  *
@@ -3199,9 +3364,7 @@ export declare interface RouteRequestRouteMatrixSyncBodyParam {
 
 /**
  *
- * **Applies to**: see pricing [tiers](https://aka.ms/AzureMapsPricingTier).
- *
- * The Matrix Routing service allows calculation of a matrix of route summaries for a set of routes defined by origin and destination locations by using an asynchronous (async) or synchronous (sync) POST request. For every given origin, the service calculates the cost of routing from that origin to every given destination. The set of origins and the set of destinations can be thought of as the column and row headers of a table and each cell in the table contains the costs of routing from the origin to the destination for that cell. As an example, let's say a food delivery company has 20 drivers and they need to find the closest driver to pick up the delivery from the restaurant. To solve this use case, they can call Matrix Route API.
+ * The `Post Route Matrix Sync` API is an HTTP `POST` request that allows calculation of a matrix of route summaries for a set of routes defined by origin and destination locations by using a single synchronous (sync) request. To make an asynchronous (async) request, see [Post Route Matrix](/rest/api/maps/route/post-route-matrix). For every given origin, the service calculates the cost of routing from that origin to every given destination. The set of origins and the set of destinations can be thought of as the column and row headers of a table and each cell in the table contains the costs of routing from the origin to the destination for that cell. As an example, let's say a food delivery company has 20 drivers and they need to find the closest driver to pick up the delivery from the restaurant. To solve this use case, they can call Matrix Route API.
  *
  *
  * For each route, the travel times and distances are returned. You can use the computed costs to determine which detailed routes to calculate using the Route Directions API.
@@ -3225,7 +3388,7 @@ export declare interface RouteRequestRouteMatrixSyncBodyParam {
  * The maximum size of a matrix for this API is **700** (the number of origins multiplied by the number of destinations). With that constraint in mind, examples of possible matrix dimensions are: 50x10, 10x10, 28x25. 10x70 (it does not need to be square).
  *
  *
- * The asynchronous responses are stored for **14** days. The redirect URL returns a 404 response if used after the expiration period.
+ * The asynchronous responses are stored for **24** hours. The redirect URL returns a 404 response if used after the expiration period.
  *
  *
  *
@@ -3289,11 +3452,29 @@ export declare interface RouteRequestRouteMatrixSyncQueryParamProperties {
     waitForResults?: boolean;
     /** Specifies whether to return additional travel times using different types of traffic information (none, historic, live) as well as the default best-estimate travel time. */
     computeTravelTimeFor?: "none" | "all";
-    /** Specifies which of the section types is reported in the route response. <br><br>For example if sectionType = pedestrian the sections which are suited for pedestrians only are returned. Multiple types can be used. The default sectionType refers to the travelMode input. By default travelMode is set to car */
-    sectionType?: "carTrain" | "country" | "ferry" | "motorway" | "pedestrian" | "tollRoad" | "tollVignette" | "traffic" | "travelMode" | "tunnel" | "carpool" | "urban";
-    /** The date and time of arrival at the destination point. It must be specified as a dateTime. When a time zone offset is not specified it will be assumed to be that of the destination point. The arriveAt value must be in the future. The arriveAt parameter cannot be used in conjunction with departAt, minDeviationDistance or minDeviationTime. */
+    /** Specifies which of the section types is reported in the route response. <br><br>For example if sectionType = pedestrian the sections which are suited for pedestrians only are returned. Can be specified multiple times in one request, for example, '&sectionType=carTrain&sectionType=pedestrian&sectionType=motorway'. The default sectionType refers to the travelMode input. By default travelMode is set to car */
+    sectionType?: Array<"carTrain" | "country" | "ferry" | "motorway" | "pedestrian" | "tollRoad" | "tollVignette" | "traffic" | "travelMode" | "tunnel" | "carpool" | "urban">;
+    /**
+     * The date and time of arrival at the destination point formatted as a `dateTime` value as defined in [RFC 3339, section 5.6](https://www.rfc-editor.org/rfc/rfc3339#section-5.6), with an optional time zone offset. When a time zone offset is not specified it will be assumed to be that of the destination point.
+     *
+     * Examples:
+     *   * 2023-12-19T16:39:57
+     *   * 2023-12-19T16:39:57-08:00
+     *
+     * The `arriveAt` parameter cannot be used in conjunction with `departAt`, `minDeviationDistance` or `minDeviationTime`.
+     */
     arriveAt?: Date | string;
-    /** The date and time of departure from the origin point. Departure times apart from now must be specified as a dateTime. When a time zone offset is not specified, it will be assumed to be that of the origin point. The departAt value must be in the future in the date-time format (1996-12-19T16:39:57-08:00). */
+    /**
+     * The date and time of departure from the origin point formatted as a `dateTime` value as defined in [RFC 3339, section 5.6](https://www.rfc-editor.org/rfc/rfc3339#section-5.6), with an optional time zone offset. When a time zone offset is not specified, it will be assumed to be that of the origin point.
+     *   * Default value: now
+     *   * Other value: `dateTime`
+     *
+     * Examples:
+     *   * 2023-12-19T16:39:57
+     *   * 2023-12-19T16:39:57-08:00
+     *
+     * The `departAt` parameter cannot be used in conjunction with `arriveAt`.
+     */
     departAt?: Date | string;
     /** Weight per axle of the vehicle in kg. A value of 0 means that weight restrictions per axle are not considered. */
     vehicleAxleWeight?: number;
@@ -3317,9 +3498,9 @@ export declare interface RouteRequestRouteMatrixSyncQueryParamProperties {
     windingness?: "low" | "normal" | "high";
     /** Degree of hilliness for thrilling route. This parameter can only be used in conjunction with `routeType`=thrilling. */
     hilliness?: "low" | "normal" | "high";
-    /** The mode of travel for the requested route. If not defined, default is 'car'. Note that the requested travelMode may not be available for the entire route. Where the requested travelMode is not available for a particular section, the travelMode element of the response for that section will be "other". Note that travel modes bus, motorcycle, taxi and van are BETA functionality. Full restriction data is not available in all areas. In **calculateReachableRange** requests, the values bicycle and pedestrian must not be used. */
+    /** The mode of travel for the requested route. If not defined, default is 'car'. Note that the requested travelMode may not be available for the entire route. Where the requested travelMode is not available for a particular section, the travelMode element of the response for that section will be "other". Note that travel modes bus, motorcycle, taxi and van are BETA functionality. Full restriction data is not available in all areas. */
     travelMode?: "car" | "truck" | "taxi" | "bus" | "van" | "motorcycle" | "bicycle" | "pedestrian";
-    /** Specifies something that the route calculation should try to avoid when determining the route. Can be specified multiple times in one request, for example, '&avoid=motorways&avoid=tollRoads&avoid=ferries'. In calculateReachableRange requests, the value alreadyUsedRoads must not be used. */
+    /** Specifies something that the route calculation should try to avoid when determining the route. Can be specified multiple times in one request, for example, '&avoid=motorways&avoid=tollRoads&avoid=ferries'. In Route Range requests, the value alreadyUsedRoads must not be used. */
     avoid?: Array<"tollRoads" | "motorways" | "ferries" | "unpavedRoads" | "carpools" | "alreadyUsedRoads" | "borderCrossings">;
     /**
      * Possible values:
@@ -3330,7 +3511,7 @@ export declare interface RouteRequestRouteMatrixSyncQueryParamProperties {
     traffic?: boolean;
     /** The type of route requested. */
     routeType?: "fastest" | "shortest" | "eco" | "thrilling";
-    /** Types of cargo that may be classified as hazardous materials and restricted from some roads. Available vehicleLoadType values are US Hazmat classes 1 through 9, plus generic classifications for use in other countries. Values beginning with USHazmat are for US routing while otherHazmat should be used for all other countries. vehicleLoadType can be specified multiple times. This parameter is currently only considered for travelMode=truck. */
+    /** Types of cargo that may be classified as hazardous materials and restricted from some roads. Available vehicleLoadType values are US Hazmat classes 1 through 9, plus generic classifications for use in other countries/regions. Values beginning with USHazmat are for US routing while otherHazmat should be used for all other countries/regions. vehicleLoadType can be specified multiple times. This parameter is currently only considered for travelMode=truck. */
     vehicleLoadType?: "USHazmatClass1" | "USHazmatClass2" | "USHazmatClass3" | "USHazmatClass4" | "USHazmatClass5" | "USHazmatClass6" | "USHazmatClass7" | "USHazmatClass8" | "USHazmatClass9" | "otherHazmatExplosive" | "otherHazmatGeneral" | "otherHazmatHarmfulToWater";
 }
 
@@ -3352,21 +3533,21 @@ export declare interface Routes {
 /** Route sections contain additional information about parts of a route. Each section contains at least the elements `startPointIndex`, `endPointIndex`, and `sectionType`. */
 export declare interface RouteSectionOutput {
     /** Index of the first point (offset 0) in the route this section applies to. */
-    startPointIndex: number;
+    readonly startPointIndex: number;
     /** Index of the last point (offset 0) in the route this section applies to. */
-    endPointIndex: number;
+    readonly endPointIndex: number;
     /** Section types of the reported route response */
-    sectionType: "CAR_TRAIN" | "COUNTRY" | "FERRY" | "MOTORWAY" | "PEDESTRIAN" | "TOLL_ROAD" | "TOLL_VIGNETTE" | "TRAFFIC" | "TRAVEL_MODE" | "TUNNEL" | "CARPOOL" | "URBAN";
+    readonly sectionType: "CAR_TRAIN" | "COUNTRY" | "FERRY" | "MOTORWAY" | "PEDESTRIAN" | "TOLL_ROAD" | "TOLL_VIGNETTE" | "TRAFFIC" | "TRAVEL_MODE" | "TUNNEL" | "CARPOOL" | "URBAN";
     /** Travel mode for the calculated route. The value will be set to `other` if the requested mode of transport is not possible in this section */
-    travelMode?: "car" | "truck" | "taxi" | "bus" | "van" | "motorcycle" | "bicycle" | "pedestrian" | "other";
+    readonly travelMode?: "car" | "truck" | "taxi" | "bus" | "van" | "motorcycle" | "bicycle" | "pedestrian" | "other";
     /** Type of the incident. Can currently be JAM, ROAD_WORK, ROAD_CLOSURE, or OTHER. See "tec" for detailed information. */
-    simpleCategory?: "JAM" | "ROAD_WORK" | "ROAD_CLOSURE" | "OTHER";
+    readonly simpleCategory?: "JAM" | "ROAD_WORK" | "ROAD_CLOSURE" | "OTHER";
     /** Effective speed of the incident in km/h, averaged over its entire length. */
-    effectiveSpeedInKmh?: number;
+    readonly effectiveSpeedInKmh?: number;
     /** Delay in seconds caused by the incident. */
-    delayInSeconds?: number;
+    readonly delayInSeconds?: number;
     /** The magnitude of delay caused by the incident. These values correspond to the values of the response field ty of the [Get Traffic Incident Detail API](https://docs.microsoft.com/rest/api/maps/traffic/gettrafficincidentdetail). */
-    magnitudeOfDelay?: "0" | "1" | "2" | "3" | "4";
+    readonly magnitudeOfDelay?: "0" | "1" | "2" | "3" | "4";
     /** Details of the traffic event, using definitions in the [TPEG2-TEC](https://www.iso.org/standard/63116.html) standard. Can contain effectCode and causes elements. */
     tec?: RouteSectionTecOutput;
 }
@@ -3374,15 +3555,15 @@ export declare interface RouteSectionOutput {
 /** The cause of the traffic event. Can contain mainCauseCode and subCauseCode elements. Can be used to define iconography and descriptions. */
 export declare interface RouteSectionTecCauseOutput {
     /** The main cause of the traffic event. Contains a value in the tec002:CauseCode table, as defined in the [TPEG2-TEC](https://www.iso.org/standard/63116.html) standard. */
-    mainCauseCode?: number;
+    readonly mainCauseCode?: number;
     /** The subcause of the traffic event. Contains a value in the sub cause table defined by the mainCauseCode, as defined in the [TPEG2-TEC](https://www.iso.org/standard/63116.html) standard. */
-    subCauseCode?: number;
+    readonly subCauseCode?: number;
 }
 
 /** Details of the traffic event, using definitions in the [TPEG2-TEC](https://www.iso.org/standard/63116.html) standard. Can contain effectCode and causes elements. */
 export declare interface RouteSectionTecOutput {
     /** The effect on the traffic flow. Contains a value in the tec001:EffectCode table, as defined in the [TPEG2-TEC](https://www.iso.org/standard/63116.html) standard. Can be used to color-code traffic events according to severity. */
-    effectCode?: number;
+    readonly effectCode?: number;
     /** Causes array */
     causes?: Array<RouteSectionTecCauseOutput>;
 }
@@ -3390,15 +3571,80 @@ export declare interface RouteSectionTecOutput {
 /** Summary object */
 export declare interface RouteSummaryOutput {
     /** Length In Meters property */
-    lengthInMeters: number;
+    readonly lengthInMeters: number;
     /** Estimated travel time in seconds property that includes the delay due to real-time traffic. Note that even when traffic=false travelTimeInSeconds still includes the delay due to traffic. If DepartAt is in the future, travel time is calculated using time-dependent historic traffic data. */
-    travelTimeInSeconds: number;
+    readonly travelTimeInSeconds: number;
     /** Estimated delay in seconds caused by the real-time incident(s) according to traffic information. For routes planned with departure time in the future, delays is always 0. To return additional travel times using different types of traffic information, parameter computeTravelTimeFor=all needs to be added. */
-    trafficDelayInSeconds: number;
-    /** The estimated departure time for the route or leg. */
-    departureTime: string;
-    /** The estimated arrival time for the route or leg. */
-    arrivalTime: string;
+    readonly trafficDelayInSeconds: number;
+    /** The estimated departure time for the route or leg. Time is in UTC. */
+    readonly departureTime: string;
+    /** The estimated arrival time for the route or leg. Time is in UTC. */
+    readonly arrivalTime: string;
+}
+
+/**
+ * A simple poller that can be used to poll a long running operation.
+ */
+export declare interface SimplePollerLike<TState extends OperationState<TResult>, TResult> {
+    /**
+     * Returns true if the poller has finished polling.
+     */
+    isDone(): boolean;
+    /**
+     * Returns the state of the operation.
+     */
+    getOperationState(): TState;
+    /**
+     * Returns the result value of the operation,
+     * regardless of the state of the poller.
+     * It can return undefined or an incomplete form of the final TResult value
+     * depending on the implementation.
+     */
+    getResult(): TResult | undefined;
+    /**
+     * Returns a promise that will resolve once a single polling request finishes.
+     * It does this by calling the update method of the Poller's operation.
+     */
+    poll(options?: {
+        abortSignal?: AbortSignalLike;
+    }): Promise<TState>;
+    /**
+     * Returns a promise that will resolve once the underlying operation is completed.
+     */
+    pollUntilDone(pollOptions?: {
+        abortSignal?: AbortSignalLike;
+    }): Promise<TResult>;
+    /**
+     * Invokes the provided callback after each polling is completed,
+     * sending the current state of the poller's operation.
+     *
+     * It returns a method that can be used to stop receiving updates on the given callback function.
+     */
+    onProgress(callback: (state: TState) => void): CancelOnProgress;
+    /**
+     * Returns a promise that could be used for serialized version of the poller's operation
+     * by invoking the operation's serialize method.
+     */
+    serialize(): Promise<string>;
+    /**
+     * Wait the poller to be submitted.
+     */
+    submitted(): Promise<void>;
+    /**
+     * Returns a string representation of the poller's operation. Similar to serialize but returns a string.
+     * @deprecated Use serialize() instead.
+     */
+    toString(): string;
+    /**
+     * Stops the poller from continuing to poll. Please note this will only stop the client-side polling
+     * @deprecated Use abortSignal to stop polling instead.
+     */
+    stopPolling(): void;
+    /**
+     * Returns true if the poller is stopped.
+     * @deprecated Use abortSignal status to track this instead.
+     */
+    isStopped(): boolean;
 }
 
 /**