@aws-sdk/client-location 3.34.0 → 3.35.0

package/src/commands/BatchDeleteGeofenceCommand.ts

@@ -0,0 +1,98 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { LocationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LocationClient";
+import { BatchDeleteGeofenceRequest, BatchDeleteGeofenceResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1BatchDeleteGeofenceCommand,
+  serializeAws_restJson1BatchDeleteGeofenceCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface BatchDeleteGeofenceCommandInput extends BatchDeleteGeofenceRequest {}
+export interface BatchDeleteGeofenceCommandOutput extends BatchDeleteGeofenceResponse, __MetadataBearer {}
+
+/**
+ * <p>Deletes a batch of geofences from a geofence collection.</p>
+ *         <note>
+ *             <p>This operation deletes the resource permanently.</p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, BatchDeleteGeofenceCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, BatchDeleteGeofenceCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new BatchDeleteGeofenceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link BatchDeleteGeofenceCommandInput} for command's `input` shape.
+ * @see {@link BatchDeleteGeofenceCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class BatchDeleteGeofenceCommand extends $Command<
+  BatchDeleteGeofenceCommandInput,
+  BatchDeleteGeofenceCommandOutput,
+  LocationClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: BatchDeleteGeofenceCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LocationClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<BatchDeleteGeofenceCommandInput, BatchDeleteGeofenceCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LocationClient";
+    const commandName = "BatchDeleteGeofenceCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: BatchDeleteGeofenceRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: BatchDeleteGeofenceResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: BatchDeleteGeofenceCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1BatchDeleteGeofenceCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<BatchDeleteGeofenceCommandOutput> {
+    return deserializeAws_restJson1BatchDeleteGeofenceCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/BatchEvaluateGeofencesCommand.ts

@@ -0,0 +1,115 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { LocationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LocationClient";
+import { BatchEvaluateGeofencesRequest, BatchEvaluateGeofencesResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1BatchEvaluateGeofencesCommand,
+  serializeAws_restJson1BatchEvaluateGeofencesCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface BatchEvaluateGeofencesCommandInput extends BatchEvaluateGeofencesRequest {}
+export interface BatchEvaluateGeofencesCommandOutput extends BatchEvaluateGeofencesResponse, __MetadataBearer {}
+
+/**
+ * <p>Evaluates device positions against the geofence geometries from a given geofence
+ *             collection.</p>
+ *         <p>This operation always returns an empty response because geofences are asynchronously
+ *             evaluated. The evaluation determines if the device has entered or exited a geofenced
+ *             area, and then publishes one of the following events to Amazon EventBridge:</p>
+ *         <ul>
+ *             <li>
+ *                 <p>
+ *                   <code>ENTER</code> if Amazon Location determines that the tracked device has entered
+ *                     a geofenced area.</p>
+ *             </li>
+ *             <li>
+ *                 <p>
+ *                   <code>EXIT</code> if Amazon Location determines that the tracked device has exited a
+ *                     geofenced area.</p>
+ *             </li>
+ *          </ul>
+ *         <note>
+ *             <p>The last geofence that a device was observed within is tracked for 30 days after
+ *                 the most recent device position update.</p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, BatchEvaluateGeofencesCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, BatchEvaluateGeofencesCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new BatchEvaluateGeofencesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link BatchEvaluateGeofencesCommandInput} for command's `input` shape.
+ * @see {@link BatchEvaluateGeofencesCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class BatchEvaluateGeofencesCommand extends $Command<
+  BatchEvaluateGeofencesCommandInput,
+  BatchEvaluateGeofencesCommandOutput,
+  LocationClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: BatchEvaluateGeofencesCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LocationClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<BatchEvaluateGeofencesCommandInput, BatchEvaluateGeofencesCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LocationClient";
+    const commandName = "BatchEvaluateGeofencesCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: BatchEvaluateGeofencesRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: BatchEvaluateGeofencesResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: BatchEvaluateGeofencesCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1BatchEvaluateGeofencesCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<BatchEvaluateGeofencesCommandOutput> {
+    return deserializeAws_restJson1BatchEvaluateGeofencesCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/BatchGetDevicePositionCommand.ts

@@ -0,0 +1,95 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { LocationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LocationClient";
+import { BatchGetDevicePositionRequest, BatchGetDevicePositionResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1BatchGetDevicePositionCommand,
+  serializeAws_restJson1BatchGetDevicePositionCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface BatchGetDevicePositionCommandInput extends BatchGetDevicePositionRequest {}
+export interface BatchGetDevicePositionCommandOutput extends BatchGetDevicePositionResponse, __MetadataBearer {}
+
+/**
+ * <p>Lists the latest device positions for requested devices.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, BatchGetDevicePositionCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, BatchGetDevicePositionCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new BatchGetDevicePositionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link BatchGetDevicePositionCommandInput} for command's `input` shape.
+ * @see {@link BatchGetDevicePositionCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class BatchGetDevicePositionCommand extends $Command<
+  BatchGetDevicePositionCommandInput,
+  BatchGetDevicePositionCommandOutput,
+  LocationClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: BatchGetDevicePositionCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LocationClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<BatchGetDevicePositionCommandInput, BatchGetDevicePositionCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LocationClient";
+    const commandName = "BatchGetDevicePositionCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: BatchGetDevicePositionRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: BatchGetDevicePositionResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: BatchGetDevicePositionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1BatchGetDevicePositionCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<BatchGetDevicePositionCommandOutput> {
+    return deserializeAws_restJson1BatchGetDevicePositionCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/BatchPutGeofenceCommand.ts

@@ -0,0 +1,96 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { LocationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LocationClient";
+import { BatchPutGeofenceRequest, BatchPutGeofenceResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1BatchPutGeofenceCommand,
+  serializeAws_restJson1BatchPutGeofenceCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface BatchPutGeofenceCommandInput extends BatchPutGeofenceRequest {}
+export interface BatchPutGeofenceCommandOutput extends BatchPutGeofenceResponse, __MetadataBearer {}
+
+/**
+ * <p>A batch request for storing geofence geometries into a given geofence collection, or
+ *             updates the geometry of an existing geofence if a geofence ID is included in the request.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, BatchPutGeofenceCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, BatchPutGeofenceCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new BatchPutGeofenceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link BatchPutGeofenceCommandInput} for command's `input` shape.
+ * @see {@link BatchPutGeofenceCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class BatchPutGeofenceCommand extends $Command<
+  BatchPutGeofenceCommandInput,
+  BatchPutGeofenceCommandOutput,
+  LocationClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: BatchPutGeofenceCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LocationClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<BatchPutGeofenceCommandInput, BatchPutGeofenceCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LocationClient";
+    const commandName = "BatchPutGeofenceCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: BatchPutGeofenceRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: BatchPutGeofenceResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: BatchPutGeofenceCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1BatchPutGeofenceCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<BatchPutGeofenceCommandOutput> {
+    return deserializeAws_restJson1BatchPutGeofenceCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/BatchUpdateDevicePositionCommand.ts

@@ -0,0 +1,104 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { LocationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LocationClient";
+import { BatchUpdateDevicePositionRequest, BatchUpdateDevicePositionResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1BatchUpdateDevicePositionCommand,
+  serializeAws_restJson1BatchUpdateDevicePositionCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface BatchUpdateDevicePositionCommandInput extends BatchUpdateDevicePositionRequest {}
+export interface BatchUpdateDevicePositionCommandOutput extends BatchUpdateDevicePositionResponse, __MetadataBearer {}
+
+/**
+ * <p>Uploads position update data for one or more devices to a tracker resource. Amazon Location
+ *             uses the data when reporting the last known device position and position history.</p>
+ *          <note>
+ *            <p>Only one position update is stored per sample time. Location data is sampled at a
+ *                 fixed rate of one position per 30-second interval and retained for 30 days before
+ *                 it's deleted.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, BatchUpdateDevicePositionCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, BatchUpdateDevicePositionCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new BatchUpdateDevicePositionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link BatchUpdateDevicePositionCommandInput} for command's `input` shape.
+ * @see {@link BatchUpdateDevicePositionCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class BatchUpdateDevicePositionCommand extends $Command<
+  BatchUpdateDevicePositionCommandInput,
+  BatchUpdateDevicePositionCommandOutput,
+  LocationClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: BatchUpdateDevicePositionCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LocationClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<BatchUpdateDevicePositionCommandInput, BatchUpdateDevicePositionCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LocationClient";
+    const commandName = "BatchUpdateDevicePositionCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: BatchUpdateDevicePositionRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: BatchUpdateDevicePositionResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: BatchUpdateDevicePositionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1BatchUpdateDevicePositionCommand(input, context);
+  }
+
+  private deserialize(
+    output: __HttpResponse,
+    context: __SerdeContext
+  ): Promise<BatchUpdateDevicePositionCommandOutput> {
+    return deserializeAws_restJson1BatchUpdateDevicePositionCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/CalculateRouteCommand.ts

@@ -0,0 +1,125 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { LocationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LocationClient";
+import { CalculateRouteRequest, CalculateRouteResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1CalculateRouteCommand,
+  serializeAws_restJson1CalculateRouteCommand,
+} from "../protocols/Aws_restJson1";
+
+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>DeparturePostiton</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/calculate-route.html#departure-time">Specifying a departure time</a> using either <code>DepartureTime</code> or
+ *                         <code>DepartureNow</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>DepartureNow</code> in a single request. Specifying both
+ *                         parameters returns an error message.</p>
+ *                 </note>
+ *             </li>
+ *             <li>
+ *                 <p>
+ *                   <a href="https://docs.aws.amazon.com/location/latest/developerguide/calculate-route.html#travel-mode">Specifying a travel mode</a> using TravelMode. This lets you specify an
+ *                     additional route preference such as <code>CarModeOptions</code> if traveling by
+ *                         <code>Car</code>, or <code>TruckModeOptions</code> if traveling by
+ *                         <code>Truck</code>.</p>
+ *             </li>
+ *          </ul>
+ *         <p>
+ *             </p>
+ * @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 command's `input` shape.
+ *
+ */
+export class CalculateRouteCommand extends $Command<
+  CalculateRouteCommandInput,
+  CalculateRouteCommandOutput,
+  LocationClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: CalculateRouteCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LocationClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<CalculateRouteCommandInput, CalculateRouteCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LocationClient";
+    const commandName = "CalculateRouteCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: CalculateRouteRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: CalculateRouteResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: CalculateRouteCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1CalculateRouteCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CalculateRouteCommandOutput> {
+    return deserializeAws_restJson1CalculateRouteCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}