@aws-sdk/client-location 3.35.0 → 3.38.0

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

@@ -6,33 +6,11 @@ export interface DeleteGeofenceCollectionCommandInput extends DeleteGeofenceColl
 }
 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/ts3.4/commands/DeleteMapCommand.d.ts

@@ -6,33 +6,11 @@ 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/ts3.4/commands/DeletePlaceIndexCommand.d.ts

@@ -6,32 +6,11 @@ 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/ts3.4/commands/DeleteRouteCalculatorCommand.d.ts

@@ -6,32 +6,11 @@ export interface DeleteRouteCalculatorCommandInput extends DeleteRouteCalculator
 }
 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/ts3.4/commands/DeleteTrackerCommand.d.ts

@@ -6,34 +6,11 @@ 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/ts3.4/commands/DescribeGeofenceCollectionCommand.d.ts

@@ -6,29 +6,11 @@ export interface DescribeGeofenceCollectionCommandInput extends DescribeGeofence
 }
 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/ts3.4/commands/DescribeMapCommand.d.ts

@@ -6,29 +6,11 @@ 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/ts3.4/commands/DescribePlaceIndexCommand.d.ts

@@ -6,29 +6,11 @@ export interface DescribePlaceIndexCommandInput extends DescribePlaceIndexReques
 }
 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/ts3.4/commands/DescribeRouteCalculatorCommand.d.ts

@@ -6,29 +6,11 @@ export interface DescribeRouteCalculatorCommandInput extends DescribeRouteCalcul
 }
 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/ts3.4/commands/DescribeTrackerCommand.d.ts

@@ -6,29 +6,11 @@ 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/ts3.4/commands/DisassociateTrackerConsumerCommand.d.ts

@@ -6,33 +6,11 @@ export interface DisassociateTrackerConsumerCommandInput extends DisassociateTra
 }
 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/ts3.4/commands/GetDevicePositionCommand.d.ts

@@ -6,32 +6,11 @@ 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/ts3.4/commands/GetDevicePositionHistoryCommand.d.ts

@@ -6,33 +6,11 @@ export interface GetDevicePositionHistoryCommandInput extends GetDevicePositionH
 }
 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;

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

@@ -6,29 +6,11 @@ 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

@@ -6,29 +6,11 @@ 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

@@ -6,31 +6,11 @@ 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

@@ -6,32 +6,11 @@ export interface GetMapStyleDescriptorCommandInput extends GetMapStyleDescriptor
 }
 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

@@ -6,34 +6,11 @@ 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;