@aws-sdk/client-dynamodb 3.31.0 → 3.35.0

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

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { DescribeTableReplicaAutoScalingInput, DescribeTableReplicaAutoScalingOutput } from "../models/models_0";
+export interface DescribeTableReplicaAutoScalingCommandInput extends DescribeTableReplicaAutoScalingInput {
+}
+export interface DescribeTableReplicaAutoScalingCommandOutput extends DescribeTableReplicaAutoScalingOutput, __MetadataBearer {
+}
+/**
+ * <p>Describes auto scaling settings across replicas of the global table at once.</p>
+ *          <note>
+ *             <p>This operation only applies to <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 2019.11.21</a> of global tables.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, DescribeTableReplicaAutoScalingCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, DescribeTableReplicaAutoScalingCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * const client = new DynamoDBClient(config);
+ * const command = new DescribeTableReplicaAutoScalingCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeTableReplicaAutoScalingCommandInput} for command's `input` shape.
+ * @see {@link DescribeTableReplicaAutoScalingCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeTableReplicaAutoScalingCommand extends $Command<DescribeTableReplicaAutoScalingCommandInput, DescribeTableReplicaAutoScalingCommandOutput, DynamoDBClientResolvedConfig> {
+    readonly input: DescribeTableReplicaAutoScalingCommandInput;
+    constructor(input: DescribeTableReplicaAutoScalingCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTableReplicaAutoScalingCommandInput, DescribeTableReplicaAutoScalingCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { DescribeTimeToLiveInput, DescribeTimeToLiveOutput } from "../models/models_0";
+export interface DescribeTimeToLiveCommandInput extends DescribeTimeToLiveInput {
+}
+export interface DescribeTimeToLiveCommandOutput extends DescribeTimeToLiveOutput, __MetadataBearer {
+}
+/**
+ * <p>Gives a description of the Time to Live (TTL) status on the specified table. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, DescribeTimeToLiveCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, DescribeTimeToLiveCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * const client = new DynamoDBClient(config);
+ * const command = new DescribeTimeToLiveCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeTimeToLiveCommandInput} for command's `input` shape.
+ * @see {@link DescribeTimeToLiveCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeTimeToLiveCommand extends $Command<DescribeTimeToLiveCommandInput, DescribeTimeToLiveCommandOutput, DynamoDBClientResolvedConfig> {
+    readonly input: DescribeTimeToLiveCommandInput;
+    constructor(input: DescribeTimeToLiveCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTimeToLiveCommandInput, DescribeTimeToLiveCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { KinesisStreamingDestinationInput, KinesisStreamingDestinationOutput } from "../models/models_0";
+export interface DisableKinesisStreamingDestinationCommandInput extends KinesisStreamingDestinationInput {
+}
+export interface DisableKinesisStreamingDestinationCommandOutput extends KinesisStreamingDestinationOutput, __MetadataBearer {
+}
+/**
+ * <p>Stops replication from the DynamoDB table to the Kinesis data stream. This is done
+ *             without deleting either of the resources.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, DisableKinesisStreamingDestinationCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, DisableKinesisStreamingDestinationCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * const client = new DynamoDBClient(config);
+ * const command = new DisableKinesisStreamingDestinationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DisableKinesisStreamingDestinationCommandInput} for command's `input` shape.
+ * @see {@link DisableKinesisStreamingDestinationCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DisableKinesisStreamingDestinationCommand extends $Command<DisableKinesisStreamingDestinationCommandInput, DisableKinesisStreamingDestinationCommandOutput, DynamoDBClientResolvedConfig> {
+    readonly input: DisableKinesisStreamingDestinationCommandInput;
+    constructor(input: DisableKinesisStreamingDestinationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisableKinesisStreamingDestinationCommandInput, DisableKinesisStreamingDestinationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { KinesisStreamingDestinationInput, KinesisStreamingDestinationOutput } from "../models/models_0";
+export interface EnableKinesisStreamingDestinationCommandInput extends KinesisStreamingDestinationInput {
+}
+export interface EnableKinesisStreamingDestinationCommandOutput extends KinesisStreamingDestinationOutput, __MetadataBearer {
+}
+/**
+ * <p>Starts table data replication to the specified Kinesis data stream at a timestamp chosen
+ *             during the enable workflow. If this operation doesn't return results immediately, use
+ *             DescribeKinesisStreamingDestination to check if streaming to the Kinesis data stream is
+ *             ACTIVE.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, EnableKinesisStreamingDestinationCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, EnableKinesisStreamingDestinationCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * const client = new DynamoDBClient(config);
+ * const command = new EnableKinesisStreamingDestinationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link EnableKinesisStreamingDestinationCommandInput} for command's `input` shape.
+ * @see {@link EnableKinesisStreamingDestinationCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class EnableKinesisStreamingDestinationCommand extends $Command<EnableKinesisStreamingDestinationCommandInput, EnableKinesisStreamingDestinationCommandOutput, DynamoDBClientResolvedConfig> {
+    readonly input: EnableKinesisStreamingDestinationCommandInput;
+    constructor(input: EnableKinesisStreamingDestinationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableKinesisStreamingDestinationCommandInput, EnableKinesisStreamingDestinationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { ExecuteStatementInput, ExecuteStatementOutput } from "../models/models_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 declare class ExecuteStatementCommand extends $Command<ExecuteStatementCommandInput, ExecuteStatementCommandOutput, DynamoDBClientResolvedConfig> {
+    readonly input: ExecuteStatementCommandInput;
+    constructor(input: ExecuteStatementCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExecuteStatementCommandInput, ExecuteStatementCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { ExecuteTransactionInput, ExecuteTransactionOutput } from "../models/models_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 declare class ExecuteTransactionCommand extends $Command<ExecuteTransactionCommandInput, ExecuteTransactionCommandOutput, DynamoDBClientResolvedConfig> {
+    readonly input: ExecuteTransactionCommandInput;
+    constructor(input: ExecuteTransactionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExecuteTransactionCommandInput, ExecuteTransactionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { ExportTableToPointInTimeInput, ExportTableToPointInTimeOutput } from "../models/models_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 declare class ExportTableToPointInTimeCommand extends $Command<ExportTableToPointInTimeCommandInput, ExportTableToPointInTimeCommandOutput, DynamoDBClientResolvedConfig> {
+    readonly input: ExportTableToPointInTimeCommandInput;
+    constructor(input: ExportTableToPointInTimeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExportTableToPointInTimeCommandInput, ExportTableToPointInTimeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,41 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { GetItemInput, GetItemOutput } from "../models/models_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 declare class GetItemCommand extends $Command<GetItemCommandInput, GetItemCommandOutput, DynamoDBClientResolvedConfig> {
+    readonly input: GetItemCommandInput;
+    constructor(input: GetItemCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetItemCommandInput, GetItemCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,41 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { ListBackupsInput, ListBackupsOutput } from "../models/models_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 declare class ListBackupsCommand extends $Command<ListBackupsCommandInput, ListBackupsCommandOutput, DynamoDBClientResolvedConfig> {
+    readonly input: ListBackupsCommandInput;
+    constructor(input: ListBackupsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListBackupsCommandInput, ListBackupsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { ListContributorInsightsInput, ListContributorInsightsOutput } from "../models/models_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 declare class ListContributorInsightsCommand extends $Command<ListContributorInsightsCommandInput, ListContributorInsightsCommandOutput, DynamoDBClientResolvedConfig> {
+    readonly input: ListContributorInsightsCommandInput;
+    constructor(input: ListContributorInsightsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListContributorInsightsCommandInput, ListContributorInsightsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { ListExportsInput, ListExportsOutput } from "../models/models_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 declare class ListExportsCommand extends $Command<ListExportsCommandInput, ListExportsCommandOutput, DynamoDBClientResolvedConfig> {
+    readonly input: ListExportsCommandInput;
+    constructor(input: ListExportsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListExportsCommandInput, ListExportsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { ListGlobalTablesInput, ListGlobalTablesOutput } from "../models/models_0";
+export interface ListGlobalTablesCommandInput extends ListGlobalTablesInput {
+}
+export interface ListGlobalTablesCommandOutput extends ListGlobalTablesOutput, __MetadataBearer {
+}
+/**
+ * <p>Lists all global tables that have a replica in the specified Region.</p>
+ *           <note>
+ *             <p>This operation only applies to <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html">Version 2017.11.29</a> of global tables.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, ListGlobalTablesCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, ListGlobalTablesCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * const client = new DynamoDBClient(config);
+ * const command = new ListGlobalTablesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListGlobalTablesCommandInput} for command's `input` shape.
+ * @see {@link ListGlobalTablesCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListGlobalTablesCommand extends $Command<ListGlobalTablesCommandInput, ListGlobalTablesCommandOutput, DynamoDBClientResolvedConfig> {
+    readonly input: ListGlobalTablesCommandInput;
+    constructor(input: ListGlobalTablesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListGlobalTablesCommandInput, ListGlobalTablesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { ListTablesInput, ListTablesOutput } from "../models/models_0";
+export interface ListTablesCommandInput extends ListTablesInput {
+}
+export interface ListTablesCommandOutput extends ListTablesOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns an array of table names associated with the current account and endpoint. The output
+ *       from <code>ListTables</code> is paginated, with each page returning a maximum of 100 table
+ *       names.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, ListTablesCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, ListTablesCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * const client = new DynamoDBClient(config);
+ * const command = new ListTablesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTablesCommandInput} for command's `input` shape.
+ * @see {@link ListTablesCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListTablesCommand extends $Command<ListTablesCommandInput, ListTablesCommandOutput, DynamoDBClientResolvedConfig> {
+    readonly input: ListTablesCommandInput;
+    constructor(input: ListTablesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTablesCommandInput, ListTablesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import { ListTagsOfResourceInput, ListTagsOfResourceOutput } from "../models/models_0";
+export interface ListTagsOfResourceCommandInput extends ListTagsOfResourceInput {
+}
+export interface ListTagsOfResourceCommandOutput extends ListTagsOfResourceOutput, __MetadataBearer {
+}
+/**
+ * <p>List all tags on an Amazon DynamoDB resource. You can call ListTagsOfResource up to 10 times per second, per account.</p>
+ *          <p>For an overview on tagging DynamoDB resources, see
+ *       <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html">Tagging for DynamoDB</a>
+ *       in the <i>Amazon DynamoDB Developer Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, ListTagsOfResourceCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, ListTagsOfResourceCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * const client = new DynamoDBClient(config);
+ * const command = new ListTagsOfResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTagsOfResourceCommandInput} for command's `input` shape.
+ * @see {@link ListTagsOfResourceCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListTagsOfResourceCommand extends $Command<ListTagsOfResourceCommandInput, ListTagsOfResourceCommandOutput, DynamoDBClientResolvedConfig> {
+    readonly input: ListTagsOfResourceCommandInput;
+    constructor(input: ListTagsOfResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsOfResourceCommandInput, ListTagsOfResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}