@aws-sdk/client-location 3.36.0 → 3.39.0

package/dist-types/ts3.4/LocationClient.d.ts

@@ -59,124 +59,59 @@ import { UpdateTrackerCommandInput, UpdateTrackerCommandOutput } from "./command
 export declare type ServiceInputTypes = AssociateTrackerConsumerCommandInput | BatchDeleteDevicePositionHistoryCommandInput | BatchDeleteGeofenceCommandInput | BatchEvaluateGeofencesCommandInput | BatchGetDevicePositionCommandInput | BatchPutGeofenceCommandInput | BatchUpdateDevicePositionCommandInput | CalculateRouteCommandInput | CreateGeofenceCollectionCommandInput | CreateMapCommandInput | CreatePlaceIndexCommandInput | CreateRouteCalculatorCommandInput | CreateTrackerCommandInput | DeleteGeofenceCollectionCommandInput | DeleteMapCommandInput | DeletePlaceIndexCommandInput | DeleteRouteCalculatorCommandInput | DeleteTrackerCommandInput | DescribeGeofenceCollectionCommandInput | DescribeMapCommandInput | DescribePlaceIndexCommandInput | DescribeRouteCalculatorCommandInput | DescribeTrackerCommandInput | DisassociateTrackerConsumerCommandInput | GetDevicePositionCommandInput | GetDevicePositionHistoryCommandInput | GetGeofenceCommandInput | GetMapGlyphsCommandInput | GetMapSpritesCommandInput | GetMapStyleDescriptorCommandInput | GetMapTileCommandInput | ListDevicePositionsCommandInput | ListGeofenceCollectionsCommandInput | ListGeofencesCommandInput | ListMapsCommandInput | ListPlaceIndexesCommandInput | ListRouteCalculatorsCommandInput | ListTagsForResourceCommandInput | ListTrackerConsumersCommandInput | ListTrackersCommandInput | PutGeofenceCommandInput | SearchPlaceIndexForPositionCommandInput | SearchPlaceIndexForTextCommandInput | TagResourceCommandInput | UntagResourceCommandInput | UpdateGeofenceCollectionCommandInput | UpdateMapCommandInput | UpdatePlaceIndexCommandInput | UpdateRouteCalculatorCommandInput | UpdateTrackerCommandInput;
 export declare type ServiceOutputTypes = AssociateTrackerConsumerCommandOutput | BatchDeleteDevicePositionHistoryCommandOutput | BatchDeleteGeofenceCommandOutput | BatchEvaluateGeofencesCommandOutput | BatchGetDevicePositionCommandOutput | BatchPutGeofenceCommandOutput | BatchUpdateDevicePositionCommandOutput | CalculateRouteCommandOutput | CreateGeofenceCollectionCommandOutput | CreateMapCommandOutput | CreatePlaceIndexCommandOutput | CreateRouteCalculatorCommandOutput | CreateTrackerCommandOutput | DeleteGeofenceCollectionCommandOutput | DeleteMapCommandOutput | DeletePlaceIndexCommandOutput | DeleteRouteCalculatorCommandOutput | DeleteTrackerCommandOutput | DescribeGeofenceCollectionCommandOutput | DescribeMapCommandOutput | DescribePlaceIndexCommandOutput | DescribeRouteCalculatorCommandOutput | DescribeTrackerCommandOutput | DisassociateTrackerConsumerCommandOutput | GetDevicePositionCommandOutput | GetDevicePositionHistoryCommandOutput | GetGeofenceCommandOutput | GetMapGlyphsCommandOutput | GetMapSpritesCommandOutput | GetMapStyleDescriptorCommandOutput | GetMapTileCommandOutput | ListDevicePositionsCommandOutput | ListGeofenceCollectionsCommandOutput | ListGeofencesCommandOutput | ListMapsCommandOutput | ListPlaceIndexesCommandOutput | ListRouteCalculatorsCommandOutput | ListTagsForResourceCommandOutput | ListTrackerConsumersCommandOutput | ListTrackersCommandOutput | PutGeofenceCommandOutput | SearchPlaceIndexForPositionCommandOutput | SearchPlaceIndexForTextCommandOutput | TagResourceCommandOutput | UntagResourceCommandOutput | UpdateGeofenceCollectionCommandOutput | UpdateMapCommandOutput | UpdatePlaceIndexCommandOutput | UpdateRouteCalculatorCommandOutput | UpdateTrackerCommandOutput;
 export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
-    /**
-     * The HTTP handler to use. Fetch in browser and Https in Nodejs.
-     */
+    
     requestHandler?: __HttpHandler;
-    /**
-     * A constructor for a class implementing the {@link __Hash} interface
-     * that computes the SHA-256 HMAC or checksum of a string or binary buffer.
-     * @internal
-     */
+    
     sha256?: __HashConstructor;
-    /**
-     * The function that will be used to convert strings into HTTP endpoints.
-     * @internal
-     */
+    
     urlParser?: __UrlParser;
-    /**
-     * A function that can calculate the length of a request body.
-     * @internal
-     */
+    
     bodyLengthChecker?: (body: any) => number | undefined;
-    /**
-     * A function that converts a stream into an array of bytes.
-     * @internal
-     */
+    
     streamCollector?: __StreamCollector;
-    /**
-     * The function that will be used to convert a base64-encoded string to a byte array.
-     * @internal
-     */
+    
     base64Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a base64-encoded string.
-     * @internal
-     */
+    
     base64Encoder?: __Encoder;
-    /**
-     * The function that will be used to convert a UTF8-encoded string to a byte array.
-     * @internal
-     */
+    
     utf8Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a UTF-8 encoded string.
-     * @internal
-     */
+    
     utf8Encoder?: __Encoder;
-    /**
-     * The runtime environment.
-     * @internal
-     */
+    
     runtime?: string;
-    /**
-     * Disable dyanamically changing the endpoint of the client based on the hostPrefix
-     * trait of an operation.
-     */
+    
     disableHostPrefix?: boolean;
-    /**
-     * Value for how many times a request will be made at most in case of retry.
-     */
+    
     maxAttempts?: number | __Provider<number>;
-    /**
-     * Specifies which retry algorithm to use.
-     */
+    
     retryMode?: string | __Provider<string>;
-    /**
-     * Optional logger for logging debug/info/warn/error.
-     */
+    
     logger?: __Logger;
-    /**
-     * Unique service identifier.
-     * @internal
-     */
+    
     serviceId?: string;
-    /**
-     * The AWS region to which this client will send requests
-     */
+    
     region?: string | __Provider<string>;
-    /**
-     * Default credentials provider; Not available in browser runtime.
-     * @internal
-     */
+    
     credentialDefaultProvider?: (input: any) => __Provider<__Credentials>;
-    /**
-     * Fetch related hostname, signing name or signing region with given region.
-     * @internal
-     */
+    
     regionInfoProvider?: RegionInfoProvider;
-    /**
-     * The provider populating default tracking information to be sent with `user-agent`, `x-amz-user-agent` header
-     * @internal
-     */
+    
     defaultUserAgentProvider?: Provider<__UserAgent>;
 }
 declare type LocationClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointsInputConfig & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig;
-/**
- * The configuration interface of LocationClient class constructor that set the region, credentials and other options.
- */
+
 export interface LocationClientConfig extends LocationClientConfigType {
 }
 declare type LocationClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RegionResolvedConfig & EndpointsResolvedConfig & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig;
-/**
- * The resolved configuration interface of LocationClient class. This is resolved and normalized from the {@link LocationClientConfig | constructor configuration interface}.
- */
+
 export interface LocationClientResolvedConfig extends LocationClientResolvedConfigType {
 }
-/**
- * Suite of geospatial services including Maps, Places, Routes, Tracking, and Geofencing
- */
+
 export declare class LocationClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, LocationClientResolvedConfig> {
-    /**
-     * The resolved configuration of LocationClient class. This is resolved and normalized from the {@link LocationClientConfig | constructor configuration interface}.
-     */
+    
     readonly config: LocationClientResolvedConfig;
     constructor(configuration: LocationClientConfig);
-    /**
-     * Destroy underlying resources, like sockets. It's usually not necessary to do this.
-     * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
-     * Otherwise, sockets might stay open for quite a long time before the server terminates them.
-     */
+    
     destroy(): void;
 }
 export {};

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

@@ -6,35 +6,11 @@ export interface AssociateTrackerConsumerCommandInput extends AssociateTrackerCo
 }
 export interface AssociateTrackerConsumerCommandOutput extends AssociateTrackerConsumerResponse, __MetadataBearer {
 }
-/**
- * <p>Creates an association between a geofence collection and a tracker resource. This
- *             allows the tracker resource to communicate location data to the linked geofence
- *             collection. </p>
- *         <p>You can associate up to five geofence collections to each tracker resource.</p>
- *         <note>
- *             <p>Currently not supported — Cross-account configurations, such as creating associations between a tracker resource in one account and a geofence collection in another account.</p>
- *         </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LocationClient, AssociateTrackerConsumerCommand } from "@aws-sdk/client-location"; // ES Modules import
- * // const { LocationClient, AssociateTrackerConsumerCommand } = require("@aws-sdk/client-location"); // CommonJS import
- * const client = new LocationClient(config);
- * const command = new AssociateTrackerConsumerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssociateTrackerConsumerCommandInput} for command's `input` shape.
- * @see {@link AssociateTrackerConsumerCommandOutput} for command's `response` shape.
- * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AssociateTrackerConsumerCommand extends $Command<AssociateTrackerConsumerCommandInput, AssociateTrackerConsumerCommandOutput, LocationClientResolvedConfig> {
     readonly input: AssociateTrackerConsumerCommandInput;
     constructor(input: AssociateTrackerConsumerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateTrackerConsumerCommandInput, AssociateTrackerConsumerCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface BatchDeleteDevicePositionHistoryCommandInput extends BatchDelet
 }
 export interface BatchDeleteDevicePositionHistoryCommandOutput extends BatchDeleteDevicePositionHistoryResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes the position history of one or more devices from a tracker resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LocationClient, BatchDeleteDevicePositionHistoryCommand } from "@aws-sdk/client-location"; // ES Modules import
- * // const { LocationClient, BatchDeleteDevicePositionHistoryCommand } = require("@aws-sdk/client-location"); // CommonJS import
- * const client = new LocationClient(config);
- * const command = new BatchDeleteDevicePositionHistoryCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link BatchDeleteDevicePositionHistoryCommandInput} for command's `input` shape.
- * @see {@link BatchDeleteDevicePositionHistoryCommandOutput} for command's `response` shape.
- * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class BatchDeleteDevicePositionHistoryCommand extends $Command<BatchDeleteDevicePositionHistoryCommandInput, BatchDeleteDevicePositionHistoryCommandOutput, LocationClientResolvedConfig> {
     readonly input: BatchDeleteDevicePositionHistoryCommandInput;
     constructor(input: BatchDeleteDevicePositionHistoryCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchDeleteDevicePositionHistoryCommandInput, BatchDeleteDevicePositionHistoryCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface BatchDeleteGeofenceCommandInput extends BatchDeleteGeofenceRequ
 }
 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 declare class BatchDeleteGeofenceCommand extends $Command<BatchDeleteGeofenceCommandInput, BatchDeleteGeofenceCommandOutput, LocationClientResolvedConfig> {
     readonly input: BatchDeleteGeofenceCommandInput;
     constructor(input: BatchDeleteGeofenceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchDeleteGeofenceCommandInput, BatchDeleteGeofenceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,49 +6,11 @@ export interface BatchEvaluateGeofencesCommandInput extends BatchEvaluateGeofenc
 }
 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 declare class BatchEvaluateGeofencesCommand extends $Command<BatchEvaluateGeofencesCommandInput, BatchEvaluateGeofencesCommandOutput, LocationClientResolvedConfig> {
     readonly input: BatchEvaluateGeofencesCommandInput;
     constructor(input: BatchEvaluateGeofencesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchEvaluateGeofencesCommandInput, BatchEvaluateGeofencesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface BatchGetDevicePositionCommandInput extends BatchGetDevicePositi
 }
 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 declare class BatchGetDevicePositionCommand extends $Command<BatchGetDevicePositionCommandInput, BatchGetDevicePositionCommandOutput, LocationClientResolvedConfig> {
     readonly input: BatchGetDevicePositionCommandInput;
     constructor(input: BatchGetDevicePositionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchGetDevicePositionCommandInput, BatchGetDevicePositionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ 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 declare class BatchPutGeofenceCommand extends $Command<BatchPutGeofenceCommandInput, BatchPutGeofenceCommandOutput, LocationClientResolvedConfig> {
     readonly input: BatchPutGeofenceCommandInput;
     constructor(input: BatchPutGeofenceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchPutGeofenceCommandInput, BatchPutGeofenceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,39 +6,11 @@ export interface BatchUpdateDevicePositionCommandInput extends BatchUpdateDevice
 }
 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 it reports the last known device position and position history. Amazon Location retains location data for 30
- *            days.</p>
- *          <note>
- *            <p>Position updates are handled based on the <code>PositionFiltering</code> property of the tracker.
- *                When <code>PositionFiltering</code> is set to <code>TimeBased</code>, updates are evaluated against linked geofence collections,
- *                and location data is stored at a maximum of one position per 30 second interval. If your update frequency is more often than
- *                every 30 seconds, only one update per 30 seconds is stored for each unique device ID.
- *                When <code>PositionFiltering</code> is set to <code>DistanceBased</code> filtering, location data is stored and evaluated against linked geofence
- *                collections only if the device has moved more than 30 m (98.4 ft).</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 declare class BatchUpdateDevicePositionCommand extends $Command<BatchUpdateDevicePositionCommandInput, BatchUpdateDevicePositionCommandOutput, LocationClientResolvedConfig> {
     readonly input: BatchUpdateDevicePositionCommandInput;
     constructor(input: BatchUpdateDevicePositionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchUpdateDevicePositionCommandInput, BatchUpdateDevicePositionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,59 +6,11 @@ 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 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/CreateGeofenceCollectionCommand.d.ts

@@ -6,29 +6,11 @@ export interface CreateGeofenceCollectionCommandInput extends CreateGeofenceColl
 }
 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 command's `input` 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

@@ -6,30 +6,11 @@ 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>
- * @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 command's `input` 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

@@ -6,30 +6,11 @@ export interface CreatePlaceIndexCommandInput extends CreatePlaceIndexRequest {
 }
 export interface CreatePlaceIndexCommandOutput extends CreatePlaceIndexResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a place index resource in your AWS account, which supports functions with
- *          geospatial data sourced from your chosen data provider.</p>
- * @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 command's `input` 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

@@ -6,32 +6,11 @@ export interface CreateRouteCalculatorCommandInput extends CreateRouteCalculator
 }
 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>
- * @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 command's `input` 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;