@aws-sdk/client-location 3.34.0 → 3.35.0

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

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

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

@@ -0,0 +1,37 @@
+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 { GetMapSpritesRequest, GetMapSpritesResponse } from "../models/models_0";
+export interface GetMapSpritesCommandInput extends GetMapSpritesRequest {
+}
+export interface GetMapSpritesCommandOutput extends GetMapSpritesResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves the sprite sheet corresponding to a map resource. The sprite sheet is a PNG
+ *             image paired with a JSON document describing the offsets of individual icons that will
+ *             be displayed on a rendered map.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, GetMapSpritesCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, GetMapSpritesCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new GetMapSpritesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetMapSpritesCommandInput} for command's `input` shape.
+ * @see {@link GetMapSpritesCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetMapSpritesCommand extends $Command<GetMapSpritesCommandInput, GetMapSpritesCommandOutput, LocationClientResolvedConfig> {
+    readonly input: GetMapSpritesCommandInput;
+    constructor(input: GetMapSpritesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetMapSpritesCommandInput, GetMapSpritesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetMapStyleDescriptorCommand.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 { GetMapStyleDescriptorRequest, GetMapStyleDescriptorResponse } from "../models/models_0";
+export interface GetMapStyleDescriptorCommandInput extends GetMapStyleDescriptorRequest {
+}
+export interface GetMapStyleDescriptorCommandOutput extends GetMapStyleDescriptorResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves the map style descriptor from a map resource. </p>
+ *         <p>The style descriptor contains specifications on how features render on a map. For
+ *             example, what data to display, what order to display the data in, and the style for the
+ *             data. Style descriptors follow the Mapbox Style Specification.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, GetMapStyleDescriptorCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, GetMapStyleDescriptorCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new GetMapStyleDescriptorCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetMapStyleDescriptorCommandInput} for command's `input` shape.
+ * @see {@link GetMapStyleDescriptorCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetMapStyleDescriptorCommand extends $Command<GetMapStyleDescriptorCommandInput, GetMapStyleDescriptorCommandOutput, LocationClientResolvedConfig> {
+    readonly input: GetMapStyleDescriptorCommandInput;
+    constructor(input: GetMapStyleDescriptorCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetMapStyleDescriptorCommandInput, GetMapStyleDescriptorCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetMapTileCommand.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 { GetMapTileRequest, GetMapTileResponse } from "../models/models_0";
+export interface GetMapTileCommandInput extends GetMapTileRequest {
+}
+export interface GetMapTileCommandOutput extends GetMapTileResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves a vector data tile from the map resource. Map tiles are used by clients to
+ *             render a map. they're addressed using a grid arrangement with an X coordinate, Y
+ *             coordinate, and Z (zoom) level. </p>
+ *         <p>The origin (0, 0) is the top left of the map. Increasing the zoom level by 1 doubles
+ *             both the X and Y dimensions, so a tile containing data for the entire world at (0/0/0)
+ *             will be split into 4 tiles at zoom 1 (1/0/0, 1/0/1, 1/1/0, 1/1/1).</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, GetMapTileCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, GetMapTileCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new GetMapTileCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetMapTileCommandInput} for command's `input` shape.
+ * @see {@link GetMapTileCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetMapTileCommand extends $Command<GetMapTileCommandInput, GetMapTileCommandOutput, LocationClientResolvedConfig> {
+    readonly input: GetMapTileCommandInput;
+    constructor(input: GetMapTileCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetMapTileCommandInput, GetMapTileCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

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

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

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

package/dist-types/ts3.4/commands/ListTagsForResourceCommand.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 { ListTagsForResourceRequest, ListTagsForResourceResponse } from "../models/models_0";
+export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequest {
+}
+export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of tags that are applied to the specified Amazon Location resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, ListTagsForResourceCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, ListTagsForResourceCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new ListTagsForResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
+ * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, LocationClientResolvedConfig> {
+    readonly input: ListTagsForResourceCommandInput;
+    constructor(input: ListTagsForResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

package/dist-types/ts3.4/commands/PutGeofenceCommand.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 { PutGeofenceRequest, PutGeofenceResponse } from "../models/models_0";
+export interface PutGeofenceCommandInput extends PutGeofenceRequest {
+}
+export interface PutGeofenceCommandOutput extends PutGeofenceResponse, __MetadataBearer {
+}
+/**
+ * <p>Stores a geofence geometry in 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, PutGeofenceCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, PutGeofenceCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new PutGeofenceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutGeofenceCommandInput} for command's `input` shape.
+ * @see {@link PutGeofenceCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutGeofenceCommand extends $Command<PutGeofenceCommandInput, PutGeofenceCommandOutput, LocationClientResolvedConfig> {
+    readonly input: PutGeofenceCommandInput;
+    constructor(input: PutGeofenceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutGeofenceCommandInput, PutGeofenceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/SearchPlaceIndexForPositionCommand.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 { SearchPlaceIndexForPositionRequest, SearchPlaceIndexForPositionResponse } from "../models/models_0";
+export interface SearchPlaceIndexForPositionCommandInput extends SearchPlaceIndexForPositionRequest {
+}
+export interface SearchPlaceIndexForPositionCommandOutput extends SearchPlaceIndexForPositionResponse, __MetadataBearer {
+}
+/**
+ * <p>Reverse geocodes a given coordinate and returns a legible address. Allows you to search
+ *          for Places or points of interest near a given position.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, SearchPlaceIndexForPositionCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, SearchPlaceIndexForPositionCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new SearchPlaceIndexForPositionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SearchPlaceIndexForPositionCommandInput} for command's `input` shape.
+ * @see {@link SearchPlaceIndexForPositionCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class SearchPlaceIndexForPositionCommand extends $Command<SearchPlaceIndexForPositionCommandInput, SearchPlaceIndexForPositionCommandOutput, LocationClientResolvedConfig> {
+    readonly input: SearchPlaceIndexForPositionCommandInput;
+    constructor(input: SearchPlaceIndexForPositionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SearchPlaceIndexForPositionCommandInput, SearchPlaceIndexForPositionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,43 @@
+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 { SearchPlaceIndexForTextRequest, SearchPlaceIndexForTextResponse } from "../models/models_0";
+export interface SearchPlaceIndexForTextCommandInput extends SearchPlaceIndexForTextRequest {
+}
+export interface SearchPlaceIndexForTextCommandOutput extends SearchPlaceIndexForTextResponse, __MetadataBearer {
+}
+/**
+ * <p>Geocodes free-form text, such as an address, name, city, or region to allow you to
+ *          search for Places or points of interest. </p>
+ *          <p>Includes the option to apply additional parameters to narrow your list of
+ *          results.</p>
+ *          <note>
+ *             <p>You can search for places near a given position using <code>BiasPosition</code>, or
+ *             filter results within a bounding box using <code>FilterBBox</code>. Providing both
+ *             parameters simultaneously returns an error.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, SearchPlaceIndexForTextCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, SearchPlaceIndexForTextCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new SearchPlaceIndexForTextCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SearchPlaceIndexForTextCommandInput} for command's `input` shape.
+ * @see {@link SearchPlaceIndexForTextCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class SearchPlaceIndexForTextCommand extends $Command<SearchPlaceIndexForTextCommandInput, SearchPlaceIndexForTextCommandOutput, LocationClientResolvedConfig> {
+    readonly input: SearchPlaceIndexForTextCommandInput;
+    constructor(input: SearchPlaceIndexForTextCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LocationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SearchPlaceIndexForTextCommandInput, SearchPlaceIndexForTextCommandOutput>;
+    private serialize;
+    private deserialize;
+}