@aws-sdk/client-location 3.31.0 → 3.35.0

package/dist-types/LocationClient.d.ts

@@ -0,0 +1,182 @@
+import { EndpointsInputConfig, EndpointsResolvedConfig, RegionInputConfig, RegionResolvedConfig } from "@aws-sdk/config-resolver";
+import { HostHeaderInputConfig, HostHeaderResolvedConfig } from "@aws-sdk/middleware-host-header";
+import { RetryInputConfig, RetryResolvedConfig } from "@aws-sdk/middleware-retry";
+import { AwsAuthInputConfig, AwsAuthResolvedConfig } from "@aws-sdk/middleware-signing";
+import { UserAgentInputConfig, UserAgentResolvedConfig } from "@aws-sdk/middleware-user-agent";
+import { HttpHandler as __HttpHandler } from "@aws-sdk/protocol-http";
+import { Client as __Client, SmithyConfiguration as __SmithyConfiguration, SmithyResolvedConfiguration as __SmithyResolvedConfiguration } from "@aws-sdk/smithy-client";
+import { Credentials as __Credentials, Decoder as __Decoder, Encoder as __Encoder, HashConstructor as __HashConstructor, HttpHandlerOptions as __HttpHandlerOptions, Logger as __Logger, Provider as __Provider, Provider, RegionInfoProvider, StreamCollector as __StreamCollector, UrlParser as __UrlParser, UserAgent as __UserAgent } from "@aws-sdk/types";
+import { AssociateTrackerConsumerCommandInput, AssociateTrackerConsumerCommandOutput } from "./commands/AssociateTrackerConsumerCommand";
+import { BatchDeleteDevicePositionHistoryCommandInput, BatchDeleteDevicePositionHistoryCommandOutput } from "./commands/BatchDeleteDevicePositionHistoryCommand";
+import { BatchDeleteGeofenceCommandInput, BatchDeleteGeofenceCommandOutput } from "./commands/BatchDeleteGeofenceCommand";
+import { BatchEvaluateGeofencesCommandInput, BatchEvaluateGeofencesCommandOutput } from "./commands/BatchEvaluateGeofencesCommand";
+import { BatchGetDevicePositionCommandInput, BatchGetDevicePositionCommandOutput } from "./commands/BatchGetDevicePositionCommand";
+import { BatchPutGeofenceCommandInput, BatchPutGeofenceCommandOutput } from "./commands/BatchPutGeofenceCommand";
+import { BatchUpdateDevicePositionCommandInput, BatchUpdateDevicePositionCommandOutput } from "./commands/BatchUpdateDevicePositionCommand";
+import { CalculateRouteCommandInput, CalculateRouteCommandOutput } from "./commands/CalculateRouteCommand";
+import { CreateGeofenceCollectionCommandInput, CreateGeofenceCollectionCommandOutput } from "./commands/CreateGeofenceCollectionCommand";
+import { CreateMapCommandInput, CreateMapCommandOutput } from "./commands/CreateMapCommand";
+import { CreatePlaceIndexCommandInput, CreatePlaceIndexCommandOutput } from "./commands/CreatePlaceIndexCommand";
+import { CreateRouteCalculatorCommandInput, CreateRouteCalculatorCommandOutput } from "./commands/CreateRouteCalculatorCommand";
+import { CreateTrackerCommandInput, CreateTrackerCommandOutput } from "./commands/CreateTrackerCommand";
+import { DeleteGeofenceCollectionCommandInput, DeleteGeofenceCollectionCommandOutput } from "./commands/DeleteGeofenceCollectionCommand";
+import { DeleteMapCommandInput, DeleteMapCommandOutput } from "./commands/DeleteMapCommand";
+import { DeletePlaceIndexCommandInput, DeletePlaceIndexCommandOutput } from "./commands/DeletePlaceIndexCommand";
+import { DeleteRouteCalculatorCommandInput, DeleteRouteCalculatorCommandOutput } from "./commands/DeleteRouteCalculatorCommand";
+import { DeleteTrackerCommandInput, DeleteTrackerCommandOutput } from "./commands/DeleteTrackerCommand";
+import { DescribeGeofenceCollectionCommandInput, DescribeGeofenceCollectionCommandOutput } from "./commands/DescribeGeofenceCollectionCommand";
+import { DescribeMapCommandInput, DescribeMapCommandOutput } from "./commands/DescribeMapCommand";
+import { DescribePlaceIndexCommandInput, DescribePlaceIndexCommandOutput } from "./commands/DescribePlaceIndexCommand";
+import { DescribeRouteCalculatorCommandInput, DescribeRouteCalculatorCommandOutput } from "./commands/DescribeRouteCalculatorCommand";
+import { DescribeTrackerCommandInput, DescribeTrackerCommandOutput } from "./commands/DescribeTrackerCommand";
+import { DisassociateTrackerConsumerCommandInput, DisassociateTrackerConsumerCommandOutput } from "./commands/DisassociateTrackerConsumerCommand";
+import { GetDevicePositionCommandInput, GetDevicePositionCommandOutput } from "./commands/GetDevicePositionCommand";
+import { GetDevicePositionHistoryCommandInput, GetDevicePositionHistoryCommandOutput } from "./commands/GetDevicePositionHistoryCommand";
+import { GetGeofenceCommandInput, GetGeofenceCommandOutput } from "./commands/GetGeofenceCommand";
+import { GetMapGlyphsCommandInput, GetMapGlyphsCommandOutput } from "./commands/GetMapGlyphsCommand";
+import { GetMapSpritesCommandInput, GetMapSpritesCommandOutput } from "./commands/GetMapSpritesCommand";
+import { GetMapStyleDescriptorCommandInput, GetMapStyleDescriptorCommandOutput } from "./commands/GetMapStyleDescriptorCommand";
+import { GetMapTileCommandInput, GetMapTileCommandOutput } from "./commands/GetMapTileCommand";
+import { ListDevicePositionsCommandInput, ListDevicePositionsCommandOutput } from "./commands/ListDevicePositionsCommand";
+import { ListGeofenceCollectionsCommandInput, ListGeofenceCollectionsCommandOutput } from "./commands/ListGeofenceCollectionsCommand";
+import { ListGeofencesCommandInput, ListGeofencesCommandOutput } from "./commands/ListGeofencesCommand";
+import { ListMapsCommandInput, ListMapsCommandOutput } from "./commands/ListMapsCommand";
+import { ListPlaceIndexesCommandInput, ListPlaceIndexesCommandOutput } from "./commands/ListPlaceIndexesCommand";
+import { ListRouteCalculatorsCommandInput, ListRouteCalculatorsCommandOutput } from "./commands/ListRouteCalculatorsCommand";
+import { ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput } from "./commands/ListTagsForResourceCommand";
+import { ListTrackerConsumersCommandInput, ListTrackerConsumersCommandOutput } from "./commands/ListTrackerConsumersCommand";
+import { ListTrackersCommandInput, ListTrackersCommandOutput } from "./commands/ListTrackersCommand";
+import { PutGeofenceCommandInput, PutGeofenceCommandOutput } from "./commands/PutGeofenceCommand";
+import { SearchPlaceIndexForPositionCommandInput, SearchPlaceIndexForPositionCommandOutput } from "./commands/SearchPlaceIndexForPositionCommand";
+import { SearchPlaceIndexForTextCommandInput, SearchPlaceIndexForTextCommandOutput } from "./commands/SearchPlaceIndexForTextCommand";
+import { TagResourceCommandInput, TagResourceCommandOutput } from "./commands/TagResourceCommand";
+import { UntagResourceCommandInput, UntagResourceCommandOutput } from "./commands/UntagResourceCommand";
+import { UpdateGeofenceCollectionCommandInput, UpdateGeofenceCollectionCommandOutput } from "./commands/UpdateGeofenceCollectionCommand";
+import { UpdateMapCommandInput, UpdateMapCommandOutput } from "./commands/UpdateMapCommand";
+import { UpdatePlaceIndexCommandInput, UpdatePlaceIndexCommandOutput } from "./commands/UpdatePlaceIndexCommand";
+import { UpdateRouteCalculatorCommandInput, UpdateRouteCalculatorCommandOutput } from "./commands/UpdateRouteCalculatorCommand";
+import { UpdateTrackerCommandInput, UpdateTrackerCommandOutput } from "./commands/UpdateTrackerCommand";
+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/commands/AssociateTrackerConsumerCommand.d.ts

@@ -0,0 +1,41 @@
+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 { AssociateTrackerConsumerRequest, AssociateTrackerConsumerResponse } from "../models/models_0";
+export interface AssociateTrackerConsumerCommandInput extends AssociateTrackerConsumerRequest {
+}
+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/commands/BatchDeleteDevicePositionHistoryCommand.d.ts

@@ -0,0 +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 { BatchDeleteDevicePositionHistoryRequest, BatchDeleteDevicePositionHistoryResponse } from "../models/models_0";
+export interface BatchDeleteDevicePositionHistoryCommandInput extends BatchDeleteDevicePositionHistoryRequest {
+}
+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/commands/BatchDeleteGeofenceCommand.d.ts

@@ -0,0 +1,38 @@
+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 { BatchDeleteGeofenceRequest, BatchDeleteGeofenceResponse } from "../models/models_0";
+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 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/commands/BatchEvaluateGeofencesCommand.d.ts

@@ -0,0 +1,55 @@
+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 { BatchEvaluateGeofencesRequest, BatchEvaluateGeofencesResponse } from "../models/models_0";
+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 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/commands/BatchGetDevicePositionCommand.d.ts

@@ -0,0 +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 { BatchGetDevicePositionRequest, BatchGetDevicePositionResponse } from "../models/models_0";
+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 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/commands/BatchPutGeofenceCommand.d.ts

@@ -0,0 +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 { BatchPutGeofenceRequest, BatchPutGeofenceResponse } from "../models/models_0";
+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/commands/BatchUpdateDevicePositionCommand.d.ts

@@ -0,0 +1,41 @@
+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 { BatchUpdateDevicePositionRequest, BatchUpdateDevicePositionResponse } from "../models/models_0";
+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 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/commands/CalculateRouteCommand.d.ts

@@ -0,0 +1,65 @@
+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>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/commands/CreateGeofenceCollectionCommand.d.ts

@@ -0,0 +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 {
+}
+/**
+ * <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/commands/CreateMapCommand.d.ts

@@ -0,0 +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 { 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>
+ * @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;
+}