@aws-sdk/client-location 3.31.0 → 3.35.0

package/src/commands/CreateGeofenceCollectionCommand.ts

@@ -0,0 +1,95 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { LocationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LocationClient";
+import { CreateGeofenceCollectionRequest, CreateGeofenceCollectionResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1CreateGeofenceCollectionCommand,
+  serializeAws_restJson1CreateGeofenceCollectionCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface CreateGeofenceCollectionCommandInput extends CreateGeofenceCollectionRequest {}
+export interface CreateGeofenceCollectionCommandOutput extends CreateGeofenceCollectionResponse, __MetadataBearer {}
+
+/**
+ * <p>Creates a geofence collection, which manages and stores geofences.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, CreateGeofenceCollectionCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, CreateGeofenceCollectionCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new CreateGeofenceCollectionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateGeofenceCollectionCommandInput} for command's `input` shape.
+ * @see {@link CreateGeofenceCollectionCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class CreateGeofenceCollectionCommand extends $Command<
+  CreateGeofenceCollectionCommandInput,
+  CreateGeofenceCollectionCommandOutput,
+  LocationClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: CreateGeofenceCollectionCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LocationClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<CreateGeofenceCollectionCommandInput, CreateGeofenceCollectionCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LocationClient";
+    const commandName = "CreateGeofenceCollectionCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: CreateGeofenceCollectionRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: CreateGeofenceCollectionResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: CreateGeofenceCollectionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1CreateGeofenceCollectionCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateGeofenceCollectionCommandOutput> {
+    return deserializeAws_restJson1CreateGeofenceCollectionCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/CreateMapCommand.ts

@@ -0,0 +1,96 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { LocationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LocationClient";
+import { CreateMapRequest, CreateMapResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1CreateMapCommand,
+  serializeAws_restJson1CreateMapCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface CreateMapCommandInput extends CreateMapRequest {}
+export interface CreateMapCommandOutput extends CreateMapResponse, __MetadataBearer {}
+
+/**
+ * <p>Creates a map resource in your AWS account, which provides map tiles of different
+ *             styles sourced from global location data providers.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LocationClient, CreateMapCommand } from "@aws-sdk/client-location"; // ES Modules import
+ * // const { LocationClient, CreateMapCommand } = require("@aws-sdk/client-location"); // CommonJS import
+ * const client = new LocationClient(config);
+ * const command = new CreateMapCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateMapCommandInput} for command's `input` shape.
+ * @see {@link CreateMapCommandOutput} for command's `response` shape.
+ * @see {@link LocationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class CreateMapCommand extends $Command<
+  CreateMapCommandInput,
+  CreateMapCommandOutput,
+  LocationClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: CreateMapCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LocationClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<CreateMapCommandInput, CreateMapCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LocationClient";
+    const commandName = "CreateMapCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: CreateMapRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: CreateMapResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: CreateMapCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1CreateMapCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateMapCommandOutput> {
+    return deserializeAws_restJson1CreateMapCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/CreatePlaceIndexCommand.ts

@@ -0,0 +1,96 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { LocationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LocationClient";
+import { CreatePlaceIndexRequest, CreatePlaceIndexResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1CreatePlaceIndexCommand,
+  serializeAws_restJson1CreatePlaceIndexCommand,
+} from "../protocols/Aws_restJson1";
+
+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 class CreatePlaceIndexCommand extends $Command<
+  CreatePlaceIndexCommandInput,
+  CreatePlaceIndexCommandOutput,
+  LocationClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: CreatePlaceIndexCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LocationClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<CreatePlaceIndexCommandInput, CreatePlaceIndexCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LocationClient";
+    const commandName = "CreatePlaceIndexCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: CreatePlaceIndexRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: CreatePlaceIndexResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: CreatePlaceIndexCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1CreatePlaceIndexCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreatePlaceIndexCommandOutput> {
+    return deserializeAws_restJson1CreatePlaceIndexCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/CreateRouteCalculatorCommand.ts

@@ -0,0 +1,98 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { LocationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LocationClient";
+import { CreateRouteCalculatorRequest, CreateRouteCalculatorResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1CreateRouteCalculatorCommand,
+  serializeAws_restJson1CreateRouteCalculatorCommand,
+} from "../protocols/Aws_restJson1";
+
+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 class CreateRouteCalculatorCommand extends $Command<
+  CreateRouteCalculatorCommandInput,
+  CreateRouteCalculatorCommandOutput,
+  LocationClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: CreateRouteCalculatorCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LocationClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<CreateRouteCalculatorCommandInput, CreateRouteCalculatorCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LocationClient";
+    const commandName = "CreateRouteCalculatorCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: CreateRouteCalculatorRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: CreateRouteCalculatorResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: CreateRouteCalculatorCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1CreateRouteCalculatorCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateRouteCalculatorCommandOutput> {
+    return deserializeAws_restJson1CreateRouteCalculatorCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/CreateTrackerCommand.ts

@@ -0,0 +1,96 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { LocationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LocationClient";
+import { CreateTrackerRequest, CreateTrackerResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1CreateTrackerCommand,
+  serializeAws_restJson1CreateTrackerCommand,
+} from "../protocols/Aws_restJson1";
+
+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 class CreateTrackerCommand extends $Command<
+  CreateTrackerCommandInput,
+  CreateTrackerCommandOutput,
+  LocationClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: CreateTrackerCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LocationClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<CreateTrackerCommandInput, CreateTrackerCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LocationClient";
+    const commandName = "CreateTrackerCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: CreateTrackerRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: CreateTrackerResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: CreateTrackerCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1CreateTrackerCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateTrackerCommandOutput> {
+    return deserializeAws_restJson1CreateTrackerCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/DeleteGeofenceCollectionCommand.ts

@@ -0,0 +1,99 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { LocationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LocationClient";
+import { DeleteGeofenceCollectionRequest, DeleteGeofenceCollectionResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1DeleteGeofenceCollectionCommand,
+  serializeAws_restJson1DeleteGeofenceCollectionCommand,
+} from "../protocols/Aws_restJson1";
+
+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 class DeleteGeofenceCollectionCommand extends $Command<
+  DeleteGeofenceCollectionCommandInput,
+  DeleteGeofenceCollectionCommandOutput,
+  LocationClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: DeleteGeofenceCollectionCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LocationClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<DeleteGeofenceCollectionCommandInput, DeleteGeofenceCollectionCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LocationClient";
+    const commandName = "DeleteGeofenceCollectionCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: DeleteGeofenceCollectionRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: DeleteGeofenceCollectionResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: DeleteGeofenceCollectionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1DeleteGeofenceCollectionCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DeleteGeofenceCollectionCommandOutput> {
+    return deserializeAws_restJson1DeleteGeofenceCollectionCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/DeleteMapCommand.ts

@@ -0,0 +1,99 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { LocationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LocationClient";
+import { DeleteMapRequest, DeleteMapResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1DeleteMapCommand,
+  serializeAws_restJson1DeleteMapCommand,
+} from "../protocols/Aws_restJson1";
+
+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 class DeleteMapCommand extends $Command<
+  DeleteMapCommandInput,
+  DeleteMapCommandOutput,
+  LocationClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: DeleteMapCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LocationClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<DeleteMapCommandInput, DeleteMapCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LocationClient";
+    const commandName = "DeleteMapCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: DeleteMapRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: DeleteMapResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: DeleteMapCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1DeleteMapCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DeleteMapCommandOutput> {
+    return deserializeAws_restJson1DeleteMapCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}