@aws-sdk/client-dynamodb 3.34.0 → 3.35.0

package/src/commands/ExecuteStatementCommand.ts

@@ -0,0 +1,97 @@
+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 { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { ExecuteStatementInput, ExecuteStatementOutput } from "../models/models_0";
+import {
+  deserializeAws_json1_0ExecuteStatementCommand,
+  serializeAws_json1_0ExecuteStatementCommand,
+} from "../protocols/Aws_json1_0";
+
+export interface ExecuteStatementCommandInput extends ExecuteStatementInput {}
+export interface ExecuteStatementCommandOutput extends ExecuteStatementOutput, __MetadataBearer {}
+
+/**
+ * <p>
+ * This operation allows you to perform reads and singleton writes on data stored in DynamoDB, using PartiQL.
+ * </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, ExecuteStatementCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, ExecuteStatementCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * const client = new DynamoDBClient(config);
+ * const command = new ExecuteStatementCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ExecuteStatementCommandInput} for command's `input` shape.
+ * @see {@link ExecuteStatementCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class ExecuteStatementCommand extends $Command<
+  ExecuteStatementCommandInput,
+  ExecuteStatementCommandOutput,
+  DynamoDBClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: ExecuteStatementCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DynamoDBClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<ExecuteStatementCommandInput, ExecuteStatementCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DynamoDBClient";
+    const commandName = "ExecuteStatementCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: ExecuteStatementInput.filterSensitiveLog,
+      outputFilterSensitiveLog: ExecuteStatementOutput.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: ExecuteStatementCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_0ExecuteStatementCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ExecuteStatementCommandOutput> {
+    return deserializeAws_json1_0ExecuteStatementCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/ExecuteTransactionCommand.ts

@@ -0,0 +1,97 @@
+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 { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { ExecuteTransactionInput, ExecuteTransactionOutput } from "../models/models_0";
+import {
+  deserializeAws_json1_0ExecuteTransactionCommand,
+  serializeAws_json1_0ExecuteTransactionCommand,
+} from "../protocols/Aws_json1_0";
+
+export interface ExecuteTransactionCommandInput extends ExecuteTransactionInput {}
+export interface ExecuteTransactionCommandOutput extends ExecuteTransactionOutput, __MetadataBearer {}
+
+/**
+ * <p>
+ * This operation allows you to perform transactional reads or writes on data stored in DynamoDB, using PartiQL.
+ * </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, ExecuteTransactionCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, ExecuteTransactionCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * const client = new DynamoDBClient(config);
+ * const command = new ExecuteTransactionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ExecuteTransactionCommandInput} for command's `input` shape.
+ * @see {@link ExecuteTransactionCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class ExecuteTransactionCommand extends $Command<
+  ExecuteTransactionCommandInput,
+  ExecuteTransactionCommandOutput,
+  DynamoDBClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: ExecuteTransactionCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DynamoDBClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<ExecuteTransactionCommandInput, ExecuteTransactionCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DynamoDBClient";
+    const commandName = "ExecuteTransactionCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: ExecuteTransactionInput.filterSensitiveLog,
+      outputFilterSensitiveLog: ExecuteTransactionOutput.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: ExecuteTransactionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_0ExecuteTransactionCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ExecuteTransactionCommandOutput> {
+    return deserializeAws_json1_0ExecuteTransactionCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/ExportTableToPointInTimeCommand.ts

@@ -0,0 +1,97 @@
+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 { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { ExportTableToPointInTimeInput, ExportTableToPointInTimeOutput } from "../models/models_0";
+import {
+  deserializeAws_json1_0ExportTableToPointInTimeCommand,
+  serializeAws_json1_0ExportTableToPointInTimeCommand,
+} from "../protocols/Aws_json1_0";
+
+export interface ExportTableToPointInTimeCommandInput extends ExportTableToPointInTimeInput {}
+export interface ExportTableToPointInTimeCommandOutput extends ExportTableToPointInTimeOutput, __MetadataBearer {}
+
+/**
+ * <p>Exports table data to an S3 bucket. The table must have point in time recovery
+ *             enabled, and you can export data from any time within the point in time recovery
+ *             window.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, ExportTableToPointInTimeCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, ExportTableToPointInTimeCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * const client = new DynamoDBClient(config);
+ * const command = new ExportTableToPointInTimeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ExportTableToPointInTimeCommandInput} for command's `input` shape.
+ * @see {@link ExportTableToPointInTimeCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class ExportTableToPointInTimeCommand extends $Command<
+  ExportTableToPointInTimeCommandInput,
+  ExportTableToPointInTimeCommandOutput,
+  DynamoDBClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: ExportTableToPointInTimeCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DynamoDBClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<ExportTableToPointInTimeCommandInput, ExportTableToPointInTimeCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DynamoDBClient";
+    const commandName = "ExportTableToPointInTimeCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: ExportTableToPointInTimeInput.filterSensitiveLog,
+      outputFilterSensitiveLog: ExportTableToPointInTimeOutput.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: ExportTableToPointInTimeCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_0ExportTableToPointInTimeCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ExportTableToPointInTimeCommandOutput> {
+    return deserializeAws_json1_0ExportTableToPointInTimeCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/GetItemCommand.ts

@@ -0,0 +1,94 @@
+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 { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { GetItemInput, GetItemOutput } from "../models/models_0";
+import { deserializeAws_json1_0GetItemCommand, serializeAws_json1_0GetItemCommand } from "../protocols/Aws_json1_0";
+
+export interface GetItemCommandInput extends GetItemInput {}
+export interface GetItemCommandOutput extends GetItemOutput, __MetadataBearer {}
+
+/**
+ * <p>The <code>GetItem</code> operation returns a set of attributes for the item with the given primary
+ *           key. If there is no matching item, <code>GetItem</code> does not return any data and there will be no <code>Item</code> element in the response.</p>
+ *          <p>
+ *             <code>GetItem</code> provides an eventually consistent read by default. If your application
+ *       requires a strongly consistent read, set <code>ConsistentRead</code> to <code>true</code>. Although
+ *       a strongly consistent read might take more time than an eventually consistent read, it always
+ *       returns the last updated value.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, GetItemCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, GetItemCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * const client = new DynamoDBClient(config);
+ * const command = new GetItemCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetItemCommandInput} for command's `input` shape.
+ * @see {@link GetItemCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class GetItemCommand extends $Command<GetItemCommandInput, GetItemCommandOutput, DynamoDBClientResolvedConfig> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: GetItemCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DynamoDBClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<GetItemCommandInput, GetItemCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DynamoDBClient";
+    const commandName = "GetItemCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: GetItemInput.filterSensitiveLog,
+      outputFilterSensitiveLog: GetItemOutput.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: GetItemCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_0GetItemCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<GetItemCommandOutput> {
+    return deserializeAws_json1_0GetItemCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/ListBackupsCommand.ts

@@ -0,0 +1,101 @@
+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 { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { ListBackupsInput, ListBackupsOutput } from "../models/models_0";
+import {
+  deserializeAws_json1_0ListBackupsCommand,
+  serializeAws_json1_0ListBackupsCommand,
+} from "../protocols/Aws_json1_0";
+
+export interface ListBackupsCommandInput extends ListBackupsInput {}
+export interface ListBackupsCommandOutput extends ListBackupsOutput, __MetadataBearer {}
+
+/**
+ * <p>List backups associated with an AWS account. To list backups for a given table, specify
+ *                 <code>TableName</code>. <code>ListBackups</code> returns a paginated list of results
+ *             with at most 1 MB worth of items in a page. You can also specify a maximum number of
+ *             entries to be returned in a page. </p>
+ *          <p>In the request, start time is inclusive, but end time is exclusive. Note that these
+ *             boundaries are for the time at which the original backup was requested.</p>
+ *          <p>You can call <code>ListBackups</code> a maximum of five times per second.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, ListBackupsCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, ListBackupsCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * const client = new DynamoDBClient(config);
+ * const command = new ListBackupsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListBackupsCommandInput} for command's `input` shape.
+ * @see {@link ListBackupsCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class ListBackupsCommand extends $Command<
+  ListBackupsCommandInput,
+  ListBackupsCommandOutput,
+  DynamoDBClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: ListBackupsCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DynamoDBClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<ListBackupsCommandInput, ListBackupsCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DynamoDBClient";
+    const commandName = "ListBackupsCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: ListBackupsInput.filterSensitiveLog,
+      outputFilterSensitiveLog: ListBackupsOutput.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: ListBackupsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_0ListBackupsCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ListBackupsCommandOutput> {
+    return deserializeAws_json1_0ListBackupsCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/ListContributorInsightsCommand.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 { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { ListContributorInsightsInput, ListContributorInsightsOutput } from "../models/models_0";
+import {
+  deserializeAws_json1_0ListContributorInsightsCommand,
+  serializeAws_json1_0ListContributorInsightsCommand,
+} from "../protocols/Aws_json1_0";
+
+export interface ListContributorInsightsCommandInput extends ListContributorInsightsInput {}
+export interface ListContributorInsightsCommandOutput extends ListContributorInsightsOutput, __MetadataBearer {}
+
+/**
+ * <p>Returns a list of ContributorInsightsSummary for a table and all its global secondary indexes.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, ListContributorInsightsCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, ListContributorInsightsCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * const client = new DynamoDBClient(config);
+ * const command = new ListContributorInsightsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListContributorInsightsCommandInput} for command's `input` shape.
+ * @see {@link ListContributorInsightsCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class ListContributorInsightsCommand extends $Command<
+  ListContributorInsightsCommandInput,
+  ListContributorInsightsCommandOutput,
+  DynamoDBClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: ListContributorInsightsCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DynamoDBClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<ListContributorInsightsCommandInput, ListContributorInsightsCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DynamoDBClient";
+    const commandName = "ListContributorInsightsCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: ListContributorInsightsInput.filterSensitiveLog,
+      outputFilterSensitiveLog: ListContributorInsightsOutput.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: ListContributorInsightsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_0ListContributorInsightsCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ListContributorInsightsCommandOutput> {
+    return deserializeAws_json1_0ListContributorInsightsCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/ListExportsCommand.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 { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { ListExportsInput, ListExportsOutput } from "../models/models_0";
+import {
+  deserializeAws_json1_0ListExportsCommand,
+  serializeAws_json1_0ListExportsCommand,
+} from "../protocols/Aws_json1_0";
+
+export interface ListExportsCommandInput extends ListExportsInput {}
+export interface ListExportsCommandOutput extends ListExportsOutput, __MetadataBearer {}
+
+/**
+ * <p>Lists completed exports within the past 90 days.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, ListExportsCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, ListExportsCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * const client = new DynamoDBClient(config);
+ * const command = new ListExportsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListExportsCommandInput} for command's `input` shape.
+ * @see {@link ListExportsCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class ListExportsCommand extends $Command<
+  ListExportsCommandInput,
+  ListExportsCommandOutput,
+  DynamoDBClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: ListExportsCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: DynamoDBClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<ListExportsCommandInput, ListExportsCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "DynamoDBClient";
+    const commandName = "ListExportsCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: ListExportsInput.filterSensitiveLog,
+      outputFilterSensitiveLog: ListExportsOutput.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: ListExportsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_0ListExportsCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ListExportsCommandOutput> {
+    return deserializeAws_json1_0ListExportsCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}