@aws-sdk/client-location 3.34.0 → 3.35.0

package/src/commands/GetMapStyleDescriptorCommand.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 { GetMapStyleDescriptorRequest, GetMapStyleDescriptorResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1GetMapStyleDescriptorCommand,
+  serializeAws_restJson1GetMapStyleDescriptorCommand,
+} from "../protocols/Aws_restJson1";
+
+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 class GetMapStyleDescriptorCommand extends $Command<
+  GetMapStyleDescriptorCommandInput,
+  GetMapStyleDescriptorCommandOutput,
+  LocationClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: GetMapStyleDescriptorCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LocationClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<GetMapStyleDescriptorCommandInput, GetMapStyleDescriptorCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LocationClient";
+    const commandName = "GetMapStyleDescriptorCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: GetMapStyleDescriptorRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: GetMapStyleDescriptorResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: GetMapStyleDescriptorCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1GetMapStyleDescriptorCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<GetMapStyleDescriptorCommandOutput> {
+    return deserializeAws_restJson1GetMapStyleDescriptorCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/GetMapTileCommand.ts

@@ -0,0 +1,100 @@
+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 { GetMapTileRequest, GetMapTileResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1GetMapTileCommand,
+  serializeAws_restJson1GetMapTileCommand,
+} from "../protocols/Aws_restJson1";
+
+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 class GetMapTileCommand extends $Command<
+  GetMapTileCommandInput,
+  GetMapTileCommandOutput,
+  LocationClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: GetMapTileCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LocationClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<GetMapTileCommandInput, GetMapTileCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LocationClient";
+    const commandName = "GetMapTileCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: GetMapTileRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: GetMapTileResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: GetMapTileCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1GetMapTileCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<GetMapTileCommandOutput> {
+    return deserializeAws_restJson1GetMapTileCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/ListDevicePositionsCommand.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 { ListDevicePositionsRequest, ListDevicePositionsResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1ListDevicePositionsCommand,
+  serializeAws_restJson1ListDevicePositionsCommand,
+} from "../protocols/Aws_restJson1";
+
+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 class ListDevicePositionsCommand extends $Command<
+  ListDevicePositionsCommandInput,
+  ListDevicePositionsCommandOutput,
+  LocationClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: ListDevicePositionsCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LocationClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<ListDevicePositionsCommandInput, ListDevicePositionsCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LocationClient";
+    const commandName = "ListDevicePositionsCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: ListDevicePositionsRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: ListDevicePositionsResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: ListDevicePositionsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1ListDevicePositionsCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ListDevicePositionsCommandOutput> {
+    return deserializeAws_restJson1ListDevicePositionsCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/ListGeofenceCollectionsCommand.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 { ListGeofenceCollectionsRequest, ListGeofenceCollectionsResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1ListGeofenceCollectionsCommand,
+  serializeAws_restJson1ListGeofenceCollectionsCommand,
+} from "../protocols/Aws_restJson1";
+
+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 class ListGeofenceCollectionsCommand extends $Command<
+  ListGeofenceCollectionsCommandInput,
+  ListGeofenceCollectionsCommandOutput,
+  LocationClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: ListGeofenceCollectionsCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LocationClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<ListGeofenceCollectionsCommandInput, ListGeofenceCollectionsCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LocationClient";
+    const commandName = "ListGeofenceCollectionsCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: ListGeofenceCollectionsRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: ListGeofenceCollectionsResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: ListGeofenceCollectionsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1ListGeofenceCollectionsCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ListGeofenceCollectionsCommandOutput> {
+    return deserializeAws_restJson1ListGeofenceCollectionsCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/ListGeofencesCommand.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 { ListGeofencesRequest, ListGeofencesResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1ListGeofencesCommand,
+  serializeAws_restJson1ListGeofencesCommand,
+} from "../protocols/Aws_restJson1";
+
+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 class ListGeofencesCommand extends $Command<
+  ListGeofencesCommandInput,
+  ListGeofencesCommandOutput,
+  LocationClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: ListGeofencesCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LocationClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<ListGeofencesCommandInput, ListGeofencesCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LocationClient";
+    const commandName = "ListGeofencesCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: ListGeofencesRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: ListGeofencesResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: ListGeofencesCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1ListGeofencesCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ListGeofencesCommandOutput> {
+    return deserializeAws_restJson1ListGeofencesCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/ListMapsCommand.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 { ListMapsRequest, ListMapsResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1ListMapsCommand,
+  serializeAws_restJson1ListMapsCommand,
+} from "../protocols/Aws_restJson1";
+
+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 class ListMapsCommand extends $Command<
+  ListMapsCommandInput,
+  ListMapsCommandOutput,
+  LocationClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: ListMapsCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LocationClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<ListMapsCommandInput, ListMapsCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LocationClient";
+    const commandName = "ListMapsCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: ListMapsRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: ListMapsResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: ListMapsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1ListMapsCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ListMapsCommandOutput> {
+    return deserializeAws_restJson1ListMapsCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/ListPlaceIndexesCommand.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 { ListPlaceIndexesRequest, ListPlaceIndexesResponse } from "../models/models_0";
+import {
+  deserializeAws_restJson1ListPlaceIndexesCommand,
+  serializeAws_restJson1ListPlaceIndexesCommand,
+} from "../protocols/Aws_restJson1";
+
+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 class ListPlaceIndexesCommand extends $Command<
+  ListPlaceIndexesCommandInput,
+  ListPlaceIndexesCommandOutput,
+  LocationClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: ListPlaceIndexesCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: LocationClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<ListPlaceIndexesCommandInput, ListPlaceIndexesCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "LocationClient";
+    const commandName = "ListPlaceIndexesCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: ListPlaceIndexesRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: ListPlaceIndexesResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: ListPlaceIndexesCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1ListPlaceIndexesCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ListPlaceIndexesCommandOutput> {
+    return deserializeAws_restJson1ListPlaceIndexesCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}