@aws-sdk/client-location 3.31.0 → 3.35.0

package/dist-types/commands/CreatePlaceIndexCommand.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 { CreatePlaceIndexRequest, CreatePlaceIndexResponse } from "../models/models_0";
+export interface CreatePlaceIndexCommandInput extends CreatePlaceIndexRequest {
+}
+export interface CreatePlaceIndexCommandOutput extends CreatePlaceIndexResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a place index resource in your AWS account, 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/commands/CreateRouteCalculatorCommand.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 { CreateRouteCalculatorRequest, CreateRouteCalculatorResponse } from "../models/models_0";
+export interface CreateRouteCalculatorCommandInput extends CreateRouteCalculatorRequest {
+}
+export interface CreateRouteCalculatorCommandOutput extends CreateRouteCalculatorResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a route calculator resource in your AWS account.</p>
+ *         <p>You can send requests to a route calculator resource to estimate travel time,
+ *             distance, and get directions. A route calculator sources traffic and road network data
+ *             from your chosen data provider.</p>
+ * @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;
+}

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

package/dist-types/commands/DeleteGeofenceCollectionCommand.d.ts

@@ -0,0 +1,39 @@
+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 { DeleteGeofenceCollectionRequest, DeleteGeofenceCollectionResponse } from "../models/models_0";
+export interface DeleteGeofenceCollectionCommandInput extends DeleteGeofenceCollectionRequest {
+}
+export interface DeleteGeofenceCollectionCommandOutput extends DeleteGeofenceCollectionResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes a geofence collection from your AWS account.</p>
+ *         <note>
+ *             <p>This operation deletes the resource permanently. If the geofence collection is the
+ *                 target of a tracker resource, the devices will no longer be monitored.</p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, DeleteGeofenceCollectionCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, DeleteGeofenceCollectionCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new DeleteGeofenceCollectionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteGeofenceCollectionCommandInput} for command's `input` shape.
+ * @see {@link DeleteGeofenceCollectionCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteGeofenceCollectionCommand extends $Command<DeleteGeofenceCollectionCommandInput, DeleteGeofenceCollectionCommandOutput, LocationClientResolvedConfig> {
+    readonly input: DeleteGeofenceCollectionCommandInput;
+    constructor(input: DeleteGeofenceCollectionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteGeofenceCollectionCommandInput, DeleteGeofenceCollectionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteMapCommand.d.ts

@@ -0,0 +1,39 @@
+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 { DeleteMapRequest, DeleteMapResponse } from "../models/models_0";
+export interface DeleteMapCommandInput extends DeleteMapRequest {
+}
+export interface DeleteMapCommandOutput extends DeleteMapResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes a map resource from your AWS account.</p>
+ *         <note>
+ *             <p>This operation deletes the resource permanently. If the map is being used in an application,
+ *                 the map may not render.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, DeleteMapCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, DeleteMapCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new DeleteMapCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteMapCommandInput} for command's `input` shape.
+ * @see {@link DeleteMapCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteMapCommand extends $Command<DeleteMapCommandInput, DeleteMapCommandOutput, LocationClientResolvedConfig> {
+    readonly input: DeleteMapCommandInput;
+    constructor(input: DeleteMapCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteMapCommandInput, DeleteMapCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeletePlaceIndexCommand.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 { DeletePlaceIndexRequest, DeletePlaceIndexResponse } from "../models/models_0";
+export interface DeletePlaceIndexCommandInput extends DeletePlaceIndexRequest {
+}
+export interface DeletePlaceIndexCommandOutput extends DeletePlaceIndexResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes a place index resource from your AWS account.</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, DeletePlaceIndexCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, DeletePlaceIndexCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new DeletePlaceIndexCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeletePlaceIndexCommandInput} for command's `input` shape.
+ * @see {@link DeletePlaceIndexCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeletePlaceIndexCommand extends $Command<DeletePlaceIndexCommandInput, DeletePlaceIndexCommandOutput, LocationClientResolvedConfig> {
+    readonly input: DeletePlaceIndexCommandInput;
+    constructor(input: DeletePlaceIndexCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeletePlaceIndexCommandInput, DeletePlaceIndexCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteRouteCalculatorCommand.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 { DeleteRouteCalculatorRequest, DeleteRouteCalculatorResponse } from "../models/models_0";
+export interface DeleteRouteCalculatorCommandInput extends DeleteRouteCalculatorRequest {
+}
+export interface DeleteRouteCalculatorCommandOutput extends DeleteRouteCalculatorResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes a route calculator resource from your AWS account.</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, DeleteRouteCalculatorCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, DeleteRouteCalculatorCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new DeleteRouteCalculatorCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteRouteCalculatorCommandInput} for command's `input` shape.
+ * @see {@link DeleteRouteCalculatorCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteRouteCalculatorCommand extends $Command<DeleteRouteCalculatorCommandInput, DeleteRouteCalculatorCommandOutput, LocationClientResolvedConfig> {
+    readonly input: DeleteRouteCalculatorCommandInput;
+    constructor(input: DeleteRouteCalculatorCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRouteCalculatorCommandInput, DeleteRouteCalculatorCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteTrackerCommand.d.ts

@@ -0,0 +1,40 @@
+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 { DeleteTrackerRequest, DeleteTrackerResponse } from "../models/models_0";
+export interface DeleteTrackerCommandInput extends DeleteTrackerRequest {
+}
+export interface DeleteTrackerCommandOutput extends DeleteTrackerResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes a tracker resource from your AWS account.</p>
+ *          <note>
+ *             <p>This operation deletes the resource permanently. If the tracker resource is in use, you may
+ *                 encounter an error. Make sure that the target resource isn't a dependency for your
+ *                 applications.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, DeleteTrackerCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, DeleteTrackerCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new DeleteTrackerCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteTrackerCommandInput} for command's `input` shape.
+ * @see {@link DeleteTrackerCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteTrackerCommand extends $Command<DeleteTrackerCommandInput, DeleteTrackerCommandOutput, LocationClientResolvedConfig> {
+    readonly input: DeleteTrackerCommandInput;
+    constructor(input: DeleteTrackerCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteTrackerCommandInput, DeleteTrackerCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribeGeofenceCollectionCommand.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 { DescribeGeofenceCollectionRequest, DescribeGeofenceCollectionResponse } from "../models/models_0";
+export interface DescribeGeofenceCollectionCommandInput extends DescribeGeofenceCollectionRequest {
+}
+export interface DescribeGeofenceCollectionCommandOutput extends DescribeGeofenceCollectionResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves the geofence collection details.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, DescribeGeofenceCollectionCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, DescribeGeofenceCollectionCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new DescribeGeofenceCollectionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeGeofenceCollectionCommandInput} for command's `input` shape.
+ * @see {@link DescribeGeofenceCollectionCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeGeofenceCollectionCommand extends $Command<DescribeGeofenceCollectionCommandInput, DescribeGeofenceCollectionCommandOutput, LocationClientResolvedConfig> {
+    readonly input: DescribeGeofenceCollectionCommandInput;
+    constructor(input: DescribeGeofenceCollectionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeGeofenceCollectionCommandInput, DescribeGeofenceCollectionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribeMapCommand.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 { DescribeMapRequest, DescribeMapResponse } from "../models/models_0";
+export interface DescribeMapCommandInput extends DescribeMapRequest {
+}
+export interface DescribeMapCommandOutput extends DescribeMapResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves the map resource details.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, DescribeMapCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, DescribeMapCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new DescribeMapCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeMapCommandInput} for command's `input` shape.
+ * @see {@link DescribeMapCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeMapCommand extends $Command<DescribeMapCommandInput, DescribeMapCommandOutput, LocationClientResolvedConfig> {
+    readonly input: DescribeMapCommandInput;
+    constructor(input: DescribeMapCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeMapCommandInput, DescribeMapCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribePlaceIndexCommand.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 { DescribePlaceIndexRequest, DescribePlaceIndexResponse } from "../models/models_0";
+export interface DescribePlaceIndexCommandInput extends DescribePlaceIndexRequest {
+}
+export interface DescribePlaceIndexCommandOutput extends DescribePlaceIndexResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves the place index resource details.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, DescribePlaceIndexCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, DescribePlaceIndexCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new DescribePlaceIndexCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribePlaceIndexCommandInput} for command's `input` shape.
+ * @see {@link DescribePlaceIndexCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribePlaceIndexCommand extends $Command<DescribePlaceIndexCommandInput, DescribePlaceIndexCommandOutput, LocationClientResolvedConfig> {
+    readonly input: DescribePlaceIndexCommandInput;
+    constructor(input: DescribePlaceIndexCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribePlaceIndexCommandInput, DescribePlaceIndexCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribeRouteCalculatorCommand.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 { DescribeRouteCalculatorRequest, DescribeRouteCalculatorResponse } from "../models/models_0";
+export interface DescribeRouteCalculatorCommandInput extends DescribeRouteCalculatorRequest {
+}
+export interface DescribeRouteCalculatorCommandOutput extends DescribeRouteCalculatorResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves the route calculator resource details.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, DescribeRouteCalculatorCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, DescribeRouteCalculatorCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new DescribeRouteCalculatorCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeRouteCalculatorCommandInput} for command's `input` shape.
+ * @see {@link DescribeRouteCalculatorCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeRouteCalculatorCommand extends $Command<DescribeRouteCalculatorCommandInput, DescribeRouteCalculatorCommandOutput, LocationClientResolvedConfig> {
+    readonly input: DescribeRouteCalculatorCommandInput;
+    constructor(input: DescribeRouteCalculatorCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeRouteCalculatorCommandInput, DescribeRouteCalculatorCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribeTrackerCommand.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 { DescribeTrackerRequest, DescribeTrackerResponse } from "../models/models_0";
+export interface DescribeTrackerCommandInput extends DescribeTrackerRequest {
+}
+export interface DescribeTrackerCommandOutput extends DescribeTrackerResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves the tracker resource details.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, DescribeTrackerCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, DescribeTrackerCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new DescribeTrackerCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeTrackerCommandInput} for command's `input` shape.
+ * @see {@link DescribeTrackerCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeTrackerCommand extends $Command<DescribeTrackerCommandInput, DescribeTrackerCommandOutput, LocationClientResolvedConfig> {
+    readonly input: DescribeTrackerCommandInput;
+    constructor(input: DescribeTrackerCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTrackerCommandInput, DescribeTrackerCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DisassociateTrackerConsumerCommand.d.ts

@@ -0,0 +1,39 @@
+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 { DisassociateTrackerConsumerRequest, DisassociateTrackerConsumerResponse } from "../models/models_0";
+export interface DisassociateTrackerConsumerCommandInput extends DisassociateTrackerConsumerRequest {
+}
+export interface DisassociateTrackerConsumerCommandOutput extends DisassociateTrackerConsumerResponse, __MetadataBearer {
+}
+/**
+ * <p>Removes the association between a tracker resource and a geofence collection.</p>
+ *         <note>
+ *             <p>Once you unlink a tracker resource from a geofence collection, the tracker
+ *                 positions will no longer be automatically evaluated against geofences.</p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, DisassociateTrackerConsumerCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, DisassociateTrackerConsumerCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new DisassociateTrackerConsumerCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DisassociateTrackerConsumerCommandInput} for command's `input` shape.
+ * @see {@link DisassociateTrackerConsumerCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DisassociateTrackerConsumerCommand extends $Command<DisassociateTrackerConsumerCommandInput, DisassociateTrackerConsumerCommandOutput, LocationClientResolvedConfig> {
+    readonly input: DisassociateTrackerConsumerCommandInput;
+    constructor(input: DisassociateTrackerConsumerCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateTrackerConsumerCommandInput, DisassociateTrackerConsumerCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetDevicePositionCommand.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 { GetDevicePositionRequest, GetDevicePositionResponse } from "../models/models_0";
+export interface GetDevicePositionCommandInput extends GetDevicePositionRequest {
+}
+export interface GetDevicePositionCommandOutput extends GetDevicePositionResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves a device's most recent position according to its sample time.</p>
+ *          <note>
+ *             <p>Device positions are deleted after 30 days.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, GetDevicePositionCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, GetDevicePositionCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new GetDevicePositionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDevicePositionCommandInput} for command's `input` shape.
+ * @see {@link GetDevicePositionCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetDevicePositionCommand extends $Command<GetDevicePositionCommandInput, GetDevicePositionCommandOutput, LocationClientResolvedConfig> {
+    readonly input: GetDevicePositionCommandInput;
+    constructor(input: GetDevicePositionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDevicePositionCommandInput, GetDevicePositionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetDevicePositionHistoryCommand.d.ts

@@ -0,0 +1,39 @@
+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 { GetDevicePositionHistoryRequest, GetDevicePositionHistoryResponse } from "../models/models_0";
+export interface GetDevicePositionHistoryCommandInput extends GetDevicePositionHistoryRequest {
+}
+export interface GetDevicePositionHistoryCommandOutput extends GetDevicePositionHistoryResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves the device position history from a tracker resource within a specified range
+ *             of time.</p>
+ *          <note>
+ *            <p>Device positions are deleted after 30 days.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, GetDevicePositionHistoryCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, GetDevicePositionHistoryCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new GetDevicePositionHistoryCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDevicePositionHistoryCommandInput} for command's `input` shape.
+ * @see {@link GetDevicePositionHistoryCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetDevicePositionHistoryCommand extends $Command<GetDevicePositionHistoryCommandInput, GetDevicePositionHistoryCommandOutput, LocationClientResolvedConfig> {
+    readonly input: GetDevicePositionHistoryCommandInput;
+    constructor(input: GetDevicePositionHistoryCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDevicePositionHistoryCommandInput, GetDevicePositionHistoryCommandOutput>;
+    private serialize;
+    private deserialize;
+}