@aws-sdk/client-dynamodb 3.34.0 → 3.35.0

package/dist/types/commands/DescribeTableReplicaAutoScalingCommand.d.ts

@@ -1,38 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DescribeTableReplicaAutoScalingInput, DescribeTableReplicaAutoScalingOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/DescribeTimeToLiveCommand.d.ts

@@ -1,35 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DescribeTimeToLiveInput, DescribeTimeToLiveOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/DisableKinesisStreamingDestinationCommand.d.ts

@@ -1,36 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { KinesisStreamingDestinationInput, KinesisStreamingDestinationOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/EnableKinesisStreamingDestinationCommand.d.ts

@@ -1,38 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { KinesisStreamingDestinationInput, KinesisStreamingDestinationOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/ExecuteStatementCommand.d.ts

@@ -1,37 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { ExecuteStatementInput, ExecuteStatementOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/ExecuteTransactionCommand.d.ts

@@ -1,37 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { ExecuteTransactionInput, ExecuteTransactionOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/ExportTableToPointInTimeCommand.d.ts

@@ -1,37 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { ExportTableToPointInTimeInput, ExportTableToPointInTimeOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/GetItemCommand.d.ts

@@ -1,41 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { GetItemInput, GetItemOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/ListBackupsCommand.d.ts

@@ -1,41 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { ListBackupsInput, ListBackupsOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/ListContributorInsightsCommand.d.ts

@@ -1,35 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { ListContributorInsightsInput, ListContributorInsightsOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/ListExportsCommand.d.ts

@@ -1,35 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { ListExportsInput, ListExportsOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/ListGlobalTablesCommand.d.ts

@@ -1,38 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { ListGlobalTablesInput, ListGlobalTablesOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/ListTablesCommand.d.ts

@@ -1,37 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { ListTablesInput, ListTablesOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/ListTagsOfResourceCommand.d.ts

@@ -1,38 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { ListTagsOfResourceInput, ListTagsOfResourceOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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;
-}