@aws-sdk/client-location 3.186.0 → 3.186.1

package/dist-types/ts3.4/commands/CalculateRouteCommand.d.ts

@@ -1,35 +1,68 @@
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@aws-sdk/types";
-import {
-  LocationClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LocationClient";
-import {
-  CalculateRouteRequest,
-  CalculateRouteResponse,
-} from "../models/models_0";
-export interface CalculateRouteCommandInput extends CalculateRouteRequest {}
-export interface CalculateRouteCommandOutput
-  extends CalculateRouteResponse,
-    __MetadataBearer {}
-export declare class CalculateRouteCommand extends $Command<
-  CalculateRouteCommandInput,
-  CalculateRouteCommandOutput,
-  LocationClientResolvedConfig
-> {
-  readonly input: CalculateRouteCommandInput;
-  constructor(input: CalculateRouteCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LocationClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CalculateRouteCommandInput, CalculateRouteCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LocationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LocationClient";
+import { CalculateRouteRequest, CalculateRouteResponse } from "../models/models_0";
+export interface CalculateRouteCommandInput extends CalculateRouteRequest {
+}
+export interface CalculateRouteCommandOutput extends CalculateRouteResponse, __MetadataBearer {
+}
+/**
+ * <p>
+ *             <a href="https://docs.aws.amazon.com/location/latest/developerguide/calculate-route.html">Calculates a route</a> given the following required parameters:
+ *                 <code>DeparturePosition</code> and <code>DestinationPosition</code>. Requires that
+ *             you first <a href="https://docs.aws.amazon.com/location-routes/latest/APIReference/API_CreateRouteCalculator.html">create a
+ *                 route calculator resource</a>.</p>
+ *         <p>By default, a request that doesn't specify a departure time uses the best time of day
+ *             to travel with the best traffic conditions when calculating the route.</p>
+ *         <p>Additional options include:</p>
+ *         <ul>
+ *             <li>
+ *                 <p>
+ *                   <a href="https://docs.aws.amazon.com/location/latest/developerguide/departure-time.html">Specifying a
+ *                         departure time</a> using either <code>DepartureTime</code> or
+ *                         <code>DepartNow</code>. This calculates a route based on predictive traffic
+ *                     data at the given time. </p>
+ *                 <note>
+ *                     <p>You can't specify both <code>DepartureTime</code> and
+ *                             <code>DepartNow</code> in a single request. Specifying both parameters
+ *                         returns a validation error.</p>
+ *                 </note>
+ *             </li>
+ *             <li>
+ *                 <p>
+ *                   <a href="https://docs.aws.amazon.com/location/latest/developerguide/travel-mode.html">Specifying a travel
+ *                         mode</a> using TravelMode sets the transportation mode used to calculate
+ *                     the routes. This also lets you specify additional route preferences in
+ *                         <code>CarModeOptions</code> if traveling by <code>Car</code>, or
+ *                         <code>TruckModeOptions</code> if traveling by <code>Truck</code>.</p>
+ *                 <note>
+ *                   <p>If you specify <code>walking</code> for the travel mode and your data
+ *                     provider is Esri, the start and destination must be within 40km.</p>
+ *                </note>
+ *             </li>
+ *          </ul>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, CalculateRouteCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, CalculateRouteCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new CalculateRouteCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CalculateRouteCommandInput} for command's `input` shape.
+ * @see {@link CalculateRouteCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for LocationClient's `config` shape.
+ *
+ */
+export declare class CalculateRouteCommand extends $Command<CalculateRouteCommandInput, CalculateRouteCommandOutput, LocationClientResolvedConfig> {
+    readonly input: CalculateRouteCommandInput;
+    constructor(input: CalculateRouteCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CalculateRouteCommandInput, CalculateRouteCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CalculateRouteMatrixCommand.d.ts

@@ -1,39 +1,76 @@
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@aws-sdk/types";
-import {
-  LocationClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LocationClient";
-import {
-  CalculateRouteMatrixRequest,
-  CalculateRouteMatrixResponse,
-} from "../models/models_0";
-export interface CalculateRouteMatrixCommandInput
-  extends CalculateRouteMatrixRequest {}
-export interface CalculateRouteMatrixCommandOutput
-  extends CalculateRouteMatrixResponse,
-    __MetadataBearer {}
-export declare class CalculateRouteMatrixCommand extends $Command<
-  CalculateRouteMatrixCommandInput,
-  CalculateRouteMatrixCommandOutput,
-  LocationClientResolvedConfig
-> {
-  readonly input: CalculateRouteMatrixCommandInput;
-  constructor(input: CalculateRouteMatrixCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LocationClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
-    CalculateRouteMatrixCommandInput,
-    CalculateRouteMatrixCommandOutput
-  >;
-  private serialize;
-  private deserialize;
-}
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LocationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LocationClient";
+import { CalculateRouteMatrixRequest, CalculateRouteMatrixResponse } from "../models/models_0";
+export interface CalculateRouteMatrixCommandInput extends CalculateRouteMatrixRequest {
+}
+export interface CalculateRouteMatrixCommandOutput extends CalculateRouteMatrixResponse, __MetadataBearer {
+}
+/**
+ * <p>
+ *             <a href="https://docs.aws.amazon.com/location/latest/developerguide/calculate-route-matrix.html"> Calculates a route
+ *                 matrix</a> given the following required parameters:
+ *                 <code>DeparturePositions</code> and <code>DestinationPositions</code>.
+ *                 <code>CalculateRouteMatrix</code> calculates routes and returns the travel time and
+ *             travel distance from each departure position to each destination position in the
+ *             request. For example, given departure positions A and B, and destination positions X and
+ *             Y, <code>CalculateRouteMatrix</code> will return time and distance for routes from A to
+ *             X, A to Y, B to X, and B to Y (in that order). The number of results returned (and
+ *             routes calculated) will be the number of <code>DeparturePositions</code> times the
+ *             number of <code>DestinationPositions</code>.</p>
+ *         <note>
+ *             <p>Your account is charged for each route calculated, not the number of
+ *                 requests.</p>
+ *         </note>
+ *         <p>Requires that you first <a href="https://docs.aws.amazon.com/location-routes/latest/APIReference/API_CreateRouteCalculator.html">create a
+ *                 route calculator resource</a>.</p>
+ *         <p>By default, a request that doesn't specify a departure time uses the best time of day
+ *             to travel with the best traffic conditions when calculating routes.</p>
+ *         <p>Additional options include:</p>
+ *         <ul>
+ *             <li>
+ *                 <p>
+ *                   <a href="https://docs.aws.amazon.com/location/latest/developerguide/departure-time.html"> Specifying a
+ *                         departure time</a> using either <code>DepartureTime</code> or
+ *                         <code>DepartNow</code>. This calculates routes based on predictive traffic
+ *                     data at the given time. </p>
+ *                 <note>
+ *                     <p>You can't specify both <code>DepartureTime</code> and
+ *                             <code>DepartNow</code> in a single request. Specifying both parameters
+ *                         returns a validation error.</p>
+ *                 </note>
+ *             </li>
+ *             <li>
+ *                 <p>
+ *                   <a href="https://docs.aws.amazon.com/location/latest/developerguide/travel-mode.html">Specifying a travel
+ *                         mode</a> using TravelMode sets the transportation mode used to calculate
+ *                     the routes. This also lets you specify additional route preferences in
+ *                         <code>CarModeOptions</code> if traveling by <code>Car</code>, or
+ *                         <code>TruckModeOptions</code> if traveling by <code>Truck</code>.</p>
+ *             </li>
+ *          </ul>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, CalculateRouteMatrixCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, CalculateRouteMatrixCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new CalculateRouteMatrixCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CalculateRouteMatrixCommandInput} for command's `input` shape.
+ * @see {@link CalculateRouteMatrixCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for LocationClient's `config` shape.
+ *
+ */
+export declare class CalculateRouteMatrixCommand extends $Command<CalculateRouteMatrixCommandInput, CalculateRouteMatrixCommandOutput, LocationClientResolvedConfig> {
+    readonly input: CalculateRouteMatrixCommandInput;
+    constructor(input: CalculateRouteMatrixCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CalculateRouteMatrixCommandInput, CalculateRouteMatrixCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateGeofenceCollectionCommand.d.ts

@@ -1,39 +1,35 @@
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@aws-sdk/types";
-import {
-  LocationClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LocationClient";
-import {
-  CreateGeofenceCollectionRequest,
-  CreateGeofenceCollectionResponse,
-} from "../models/models_0";
-export interface CreateGeofenceCollectionCommandInput
-  extends CreateGeofenceCollectionRequest {}
-export interface CreateGeofenceCollectionCommandOutput
-  extends CreateGeofenceCollectionResponse,
-    __MetadataBearer {}
-export declare class CreateGeofenceCollectionCommand extends $Command<
-  CreateGeofenceCollectionCommandInput,
-  CreateGeofenceCollectionCommandOutput,
-  LocationClientResolvedConfig
-> {
-  readonly input: CreateGeofenceCollectionCommandInput;
-  constructor(input: CreateGeofenceCollectionCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LocationClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
-    CreateGeofenceCollectionCommandInput,
-    CreateGeofenceCollectionCommandOutput
-  >;
-  private serialize;
-  private deserialize;
-}
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LocationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LocationClient";
+import { CreateGeofenceCollectionRequest, CreateGeofenceCollectionResponse } from "../models/models_0";
+export interface CreateGeofenceCollectionCommandInput extends CreateGeofenceCollectionRequest {
+}
+export interface CreateGeofenceCollectionCommandOutput extends CreateGeofenceCollectionResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a geofence collection, which manages and stores geofences.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, CreateGeofenceCollectionCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, CreateGeofenceCollectionCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new CreateGeofenceCollectionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateGeofenceCollectionCommandInput} for command's `input` shape.
+ * @see {@link CreateGeofenceCollectionCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for LocationClient's `config` shape.
+ *
+ */
+export declare class CreateGeofenceCollectionCommand extends $Command<CreateGeofenceCollectionCommandInput, CreateGeofenceCollectionCommandOutput, LocationClientResolvedConfig> {
+    readonly input: CreateGeofenceCollectionCommandInput;
+    constructor(input: CreateGeofenceCollectionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateGeofenceCollectionCommandInput, CreateGeofenceCollectionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateMapCommand.d.ts

@@ -1,32 +1,42 @@
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@aws-sdk/types";
-import {
-  LocationClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LocationClient";
-import { CreateMapRequest, CreateMapResponse } from "../models/models_0";
-export interface CreateMapCommandInput extends CreateMapRequest {}
-export interface CreateMapCommandOutput
-  extends CreateMapResponse,
-    __MetadataBearer {}
-export declare class CreateMapCommand extends $Command<
-  CreateMapCommandInput,
-  CreateMapCommandOutput,
-  LocationClientResolvedConfig
-> {
-  readonly input: CreateMapCommandInput;
-  constructor(input: CreateMapCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LocationClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateMapCommandInput, CreateMapCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LocationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LocationClient";
+import { CreateMapRequest, CreateMapResponse } from "../models/models_0";
+export interface CreateMapCommandInput extends CreateMapRequest {
+}
+export interface CreateMapCommandOutput extends CreateMapResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a map resource in your AWS account, which provides map tiles of different
+ *             styles sourced from global location data providers.</p>
+ *         <note>
+ *             <p>If your application is tracking or routing assets you use in your business, such
+ *                 as delivery vehicles or employees, you may only use HERE as your geolocation
+ *                 provider. See section 82 of the <a href="http://aws.amazon.com/service-terms">AWS
+ *                     service terms</a> for more details.</p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, CreateMapCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, CreateMapCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new CreateMapCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateMapCommandInput} for command's `input` shape.
+ * @see {@link CreateMapCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for LocationClient's `config` shape.
+ *
+ */
+export declare class CreateMapCommand extends $Command<CreateMapCommandInput, CreateMapCommandOutput, LocationClientResolvedConfig> {
+    readonly input: CreateMapCommandInput;
+    constructor(input: CreateMapCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateMapCommandInput, CreateMapCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreatePlaceIndexCommand.d.ts

@@ -1,35 +1,45 @@
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@aws-sdk/types";
-import {
-  LocationClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LocationClient";
-import {
-  CreatePlaceIndexRequest,
-  CreatePlaceIndexResponse,
-} from "../models/models_0";
-export interface CreatePlaceIndexCommandInput extends CreatePlaceIndexRequest {}
-export interface CreatePlaceIndexCommandOutput
-  extends CreatePlaceIndexResponse,
-    __MetadataBearer {}
-export declare class CreatePlaceIndexCommand extends $Command<
-  CreatePlaceIndexCommandInput,
-  CreatePlaceIndexCommandOutput,
-  LocationClientResolvedConfig
-> {
-  readonly input: CreatePlaceIndexCommandInput;
-  constructor(input: CreatePlaceIndexCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LocationClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreatePlaceIndexCommandInput, CreatePlaceIndexCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LocationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LocationClient";
+import { CreatePlaceIndexRequest, CreatePlaceIndexResponse } from "../models/models_0";
+export interface CreatePlaceIndexCommandInput extends CreatePlaceIndexRequest {
+}
+export interface CreatePlaceIndexCommandOutput extends CreatePlaceIndexResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a place index resource in your AWS account. Use a place index resource to
+ *             geocode addresses and other text queries by using the
+ *                 <code>SearchPlaceIndexForText</code> operation, and reverse geocode coordinates by
+ *             using the <code>SearchPlaceIndexForPosition</code> operation, and enable autosuggestions
+ *             by using the <code>SearchPlaceIndexForSuggestions</code> operation.</p>
+ *         <note>
+ *             <p>If your application is tracking or routing assets you use in your business, such
+ *                 as delivery vehicles or employees, you may only use HERE as your geolocation
+ *                 provider. See section 82 of the <a href="http://aws.amazon.com/service-terms">AWS
+ *                     service terms</a> for more details.</p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, CreatePlaceIndexCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, CreatePlaceIndexCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new CreatePlaceIndexCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreatePlaceIndexCommandInput} for command's `input` shape.
+ * @see {@link CreatePlaceIndexCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for LocationClient's `config` shape.
+ *
+ */
+export declare class CreatePlaceIndexCommand extends $Command<CreatePlaceIndexCommandInput, CreatePlaceIndexCommandOutput, LocationClientResolvedConfig> {
+    readonly input: CreatePlaceIndexCommandInput;
+    constructor(input: CreatePlaceIndexCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreatePlaceIndexCommandInput, CreatePlaceIndexCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateRouteCalculatorCommand.d.ts

@@ -1,39 +1,44 @@
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@aws-sdk/types";
-import {
-  LocationClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LocationClient";
-import {
-  CreateRouteCalculatorRequest,
-  CreateRouteCalculatorResponse,
-} from "../models/models_0";
-export interface CreateRouteCalculatorCommandInput
-  extends CreateRouteCalculatorRequest {}
-export interface CreateRouteCalculatorCommandOutput
-  extends CreateRouteCalculatorResponse,
-    __MetadataBearer {}
-export declare class CreateRouteCalculatorCommand extends $Command<
-  CreateRouteCalculatorCommandInput,
-  CreateRouteCalculatorCommandOutput,
-  LocationClientResolvedConfig
-> {
-  readonly input: CreateRouteCalculatorCommandInput;
-  constructor(input: CreateRouteCalculatorCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LocationClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<
-    CreateRouteCalculatorCommandInput,
-    CreateRouteCalculatorCommandOutput
-  >;
-  private serialize;
-  private deserialize;
-}
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LocationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LocationClient";
+import { CreateRouteCalculatorRequest, CreateRouteCalculatorResponse } from "../models/models_0";
+export interface CreateRouteCalculatorCommandInput extends CreateRouteCalculatorRequest {
+}
+export interface CreateRouteCalculatorCommandOutput extends CreateRouteCalculatorResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a route calculator resource in your AWS account.</p>
+ *         <p>You can send requests to a route calculator resource to estimate travel time,
+ *             distance, and get directions. A route calculator sources traffic and road network data
+ *             from your chosen data provider.</p>
+ *         <note>
+ *             <p>If your application is tracking or routing assets you use in your business, such
+ *                 as delivery vehicles or employees, you may only use HERE as your geolocation
+ *                 provider. See section 82 of the <a href="http://aws.amazon.com/service-terms">AWS
+ *                     service terms</a> for more details.</p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, CreateRouteCalculatorCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, CreateRouteCalculatorCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new CreateRouteCalculatorCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateRouteCalculatorCommandInput} for command's `input` shape.
+ * @see {@link CreateRouteCalculatorCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for LocationClient's `config` shape.
+ *
+ */
+export declare class CreateRouteCalculatorCommand extends $Command<CreateRouteCalculatorCommandInput, CreateRouteCalculatorCommandOutput, LocationClientResolvedConfig> {
+    readonly input: CreateRouteCalculatorCommandInput;
+    constructor(input: CreateRouteCalculatorCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRouteCalculatorCommandInput, CreateRouteCalculatorCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateTrackerCommand.d.ts

@@ -1,35 +1,36 @@
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@aws-sdk/types";
-import {
-  LocationClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LocationClient";
-import {
-  CreateTrackerRequest,
-  CreateTrackerResponse,
-} from "../models/models_0";
-export interface CreateTrackerCommandInput extends CreateTrackerRequest {}
-export interface CreateTrackerCommandOutput
-  extends CreateTrackerResponse,
-    __MetadataBearer {}
-export declare class CreateTrackerCommand extends $Command<
-  CreateTrackerCommandInput,
-  CreateTrackerCommandOutput,
-  LocationClientResolvedConfig
-> {
-  readonly input: CreateTrackerCommandInput;
-  constructor(input: CreateTrackerCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LocationClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateTrackerCommandInput, CreateTrackerCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LocationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LocationClient";
+import { CreateTrackerRequest, CreateTrackerResponse } from "../models/models_0";
+export interface CreateTrackerCommandInput extends CreateTrackerRequest {
+}
+export interface CreateTrackerCommandOutput extends CreateTrackerResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a tracker resource in your AWS account, which lets you retrieve current and
+ *             historical location of devices.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, CreateTrackerCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, CreateTrackerCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new CreateTrackerCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateTrackerCommandInput} for command's `input` shape.
+ * @see {@link CreateTrackerCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for LocationClient's `config` shape.
+ *
+ */
+export declare class CreateTrackerCommand extends $Command<CreateTrackerCommandInput, CreateTrackerCommandOutput, LocationClientResolvedConfig> {
+    readonly input: CreateTrackerCommandInput;
+    constructor(input: CreateTrackerCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTrackerCommandInput, CreateTrackerCommandOutput>;
+    private serialize;
+    private deserialize;
+}