import { HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
import { BatchExecuteStatementCommandInput, BatchExecuteStatementCommandOutput } from "./commands/BatchExecuteStatementCommand";
import { BatchGetItemCommandInput, BatchGetItemCommandOutput } from "./commands/BatchGetItemCommand";
import { BatchWriteItemCommandInput, BatchWriteItemCommandOutput } from "./commands/BatchWriteItemCommand";
import { CreateBackupCommandInput, CreateBackupCommandOutput } from "./commands/CreateBackupCommand";
import { CreateGlobalTableCommandInput, CreateGlobalTableCommandOutput } from "./commands/CreateGlobalTableCommand";
import { CreateTableCommandInput, CreateTableCommandOutput } from "./commands/CreateTableCommand";
import { DeleteBackupCommandInput, DeleteBackupCommandOutput } from "./commands/DeleteBackupCommand";
import { DeleteItemCommandInput, DeleteItemCommandOutput } from "./commands/DeleteItemCommand";
import { DeleteTableCommandInput, DeleteTableCommandOutput } from "./commands/DeleteTableCommand";
import { DescribeBackupCommandInput, DescribeBackupCommandOutput } from "./commands/DescribeBackupCommand";
import { DescribeContinuousBackupsCommandInput, DescribeContinuousBackupsCommandOutput } from "./commands/DescribeContinuousBackupsCommand";
import { DescribeContributorInsightsCommandInput, DescribeContributorInsightsCommandOutput } from "./commands/DescribeContributorInsightsCommand";
import { DescribeEndpointsCommandInput, DescribeEndpointsCommandOutput } from "./commands/DescribeEndpointsCommand";
import { DescribeExportCommandInput, DescribeExportCommandOutput } from "./commands/DescribeExportCommand";
import { DescribeGlobalTableCommandInput, DescribeGlobalTableCommandOutput } from "./commands/DescribeGlobalTableCommand";
import { DescribeGlobalTableSettingsCommandInput, DescribeGlobalTableSettingsCommandOutput } from "./commands/DescribeGlobalTableSettingsCommand";
import { DescribeImportCommandInput, DescribeImportCommandOutput } from "./commands/DescribeImportCommand";
import { DescribeKinesisStreamingDestinationCommandInput, DescribeKinesisStreamingDestinationCommandOutput } from "./commands/DescribeKinesisStreamingDestinationCommand";
import { DescribeLimitsCommandInput, DescribeLimitsCommandOutput } from "./commands/DescribeLimitsCommand";
import { DescribeTableCommandInput, DescribeTableCommandOutput } from "./commands/DescribeTableCommand";
import { DescribeTableReplicaAutoScalingCommandInput, DescribeTableReplicaAutoScalingCommandOutput } from "./commands/DescribeTableReplicaAutoScalingCommand";
import { DescribeTimeToLiveCommandInput, DescribeTimeToLiveCommandOutput } from "./commands/DescribeTimeToLiveCommand";
import { DisableKinesisStreamingDestinationCommandInput, DisableKinesisStreamingDestinationCommandOutput } from "./commands/DisableKinesisStreamingDestinationCommand";
import { EnableKinesisStreamingDestinationCommandInput, EnableKinesisStreamingDestinationCommandOutput } from "./commands/EnableKinesisStreamingDestinationCommand";
import { ExecuteStatementCommandInput, ExecuteStatementCommandOutput } from "./commands/ExecuteStatementCommand";
import { ExecuteTransactionCommandInput, ExecuteTransactionCommandOutput } from "./commands/ExecuteTransactionCommand";
import { ExportTableToPointInTimeCommandInput, ExportTableToPointInTimeCommandOutput } from "./commands/ExportTableToPointInTimeCommand";
import { GetItemCommandInput, GetItemCommandOutput } from "./commands/GetItemCommand";
import { ImportTableCommandInput, ImportTableCommandOutput } from "./commands/ImportTableCommand";
import { ListBackupsCommandInput, ListBackupsCommandOutput } from "./commands/ListBackupsCommand";
import { ListContributorInsightsCommandInput, ListContributorInsightsCommandOutput } from "./commands/ListContributorInsightsCommand";
import { ListExportsCommandInput, ListExportsCommandOutput } from "./commands/ListExportsCommand";
import { ListGlobalTablesCommandInput, ListGlobalTablesCommandOutput } from "./commands/ListGlobalTablesCommand";
import { ListImportsCommandInput, ListImportsCommandOutput } from "./commands/ListImportsCommand";
import { ListTablesCommandInput, ListTablesCommandOutput } from "./commands/ListTablesCommand";
import { ListTagsOfResourceCommandInput, ListTagsOfResourceCommandOutput } from "./commands/ListTagsOfResourceCommand";
import { PutItemCommandInput, PutItemCommandOutput } from "./commands/PutItemCommand";
import { QueryCommandInput, QueryCommandOutput } from "./commands/QueryCommand";
import { RestoreTableFromBackupCommandInput, RestoreTableFromBackupCommandOutput } from "./commands/RestoreTableFromBackupCommand";
import { RestoreTableToPointInTimeCommandInput, RestoreTableToPointInTimeCommandOutput } from "./commands/RestoreTableToPointInTimeCommand";
import { ScanCommandInput, ScanCommandOutput } from "./commands/ScanCommand";
import { TagResourceCommandInput, TagResourceCommandOutput } from "./commands/TagResourceCommand";
import { TransactGetItemsCommandInput, TransactGetItemsCommandOutput } from "./commands/TransactGetItemsCommand";
import { TransactWriteItemsCommandInput, TransactWriteItemsCommandOutput } from "./commands/TransactWriteItemsCommand";
import { UntagResourceCommandInput, UntagResourceCommandOutput } from "./commands/UntagResourceCommand";
import { UpdateContinuousBackupsCommandInput, UpdateContinuousBackupsCommandOutput } from "./commands/UpdateContinuousBackupsCommand";
import { UpdateContributorInsightsCommandInput, UpdateContributorInsightsCommandOutput } from "./commands/UpdateContributorInsightsCommand";
import { UpdateGlobalTableCommandInput, UpdateGlobalTableCommandOutput } from "./commands/UpdateGlobalTableCommand";
import { UpdateGlobalTableSettingsCommandInput, UpdateGlobalTableSettingsCommandOutput } from "./commands/UpdateGlobalTableSettingsCommand";
import { UpdateItemCommandInput, UpdateItemCommandOutput } from "./commands/UpdateItemCommand";
import { UpdateTableCommandInput, UpdateTableCommandOutput } from "./commands/UpdateTableCommand";
import { UpdateTableReplicaAutoScalingCommandInput, UpdateTableReplicaAutoScalingCommandOutput } from "./commands/UpdateTableReplicaAutoScalingCommand";
import { UpdateTimeToLiveCommandInput, UpdateTimeToLiveCommandOutput } from "./commands/UpdateTimeToLiveCommand";
import { DynamoDBClient } from "./DynamoDBClient";
/**
 * <fullname>Amazon DynamoDB</fullname>
 *
 *         <p>Amazon DynamoDB is a fully managed NoSQL database service that provides fast
 *             and predictable performance with seamless scalability. DynamoDB lets you
 *             offload the administrative burdens of operating and scaling a distributed database, so
 *             that you don't have to worry about hardware provisioning, setup and configuration,
 *             replication, software patching, or cluster scaling.</p>
 *
 *         <p>With DynamoDB, you can create database tables that can store and retrieve
 *             any amount of data, and serve any level of request traffic. You can scale up or scale
 *             down your tables' throughput capacity without downtime or performance degradation, and
 *             use the Amazon Web Services Management Console to monitor resource utilization and performance
 *             metrics.</p>
 *
 *         <p>DynamoDB automatically spreads the data and traffic for your tables over
 *             a sufficient number of servers to handle your throughput and storage requirements, while
 *             maintaining consistent and fast performance. All of your data is stored on solid state
 *             disks (SSDs) and automatically replicated across multiple Availability Zones in an
 *                 Amazon Web Services Region, providing built-in high availability and data
 *             durability.</p>
 */
export declare class DynamoDB extends DynamoDBClient {
    /**
     * <p>This operation allows you to perform batch reads or writes on data stored in DynamoDB,
     *             using PartiQL. Each read statement in a <code>BatchExecuteStatement</code> must specify
     *             an equality condition on all key attributes. This enforces that each <code>SELECT</code>
     *             statement in a batch returns at most a single item.</p>
     *         <note>
     *             <p>The entire batch must consist of either read statements or write statements, you
     *                 cannot mix both in one batch.</p>
     *         </note>
     *         <important>
     *             <p>A HTTP 200 response does not mean that all statements in the BatchExecuteStatement
     *                 succeeded. Error details for individual statements can be found under the <a href="https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_BatchStatementResponse.html#DDB-Type-BatchStatementResponse-Error">Error</a> field of the <code>BatchStatementResponse</code> for each
     *                 statement.</p>
     *         </important>
     */
    batchExecuteStatement(args: BatchExecuteStatementCommandInput, options?: __HttpHandlerOptions): Promise<BatchExecuteStatementCommandOutput>;
    batchExecuteStatement(args: BatchExecuteStatementCommandInput, cb: (err: any, data?: BatchExecuteStatementCommandOutput) => void): void;
    batchExecuteStatement(args: BatchExecuteStatementCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: BatchExecuteStatementCommandOutput) => void): void;
    /**
     * <p>The <code>BatchGetItem</code> operation returns the attributes of one or more items
     *             from one or more tables. You identify requested items by primary key.</p>
     *         <p>A single operation can retrieve up to 16 MB of data, which can contain as many as 100
     *             items. <code>BatchGetItem</code> returns a partial result if the response size limit is
     *             exceeded, the table's provisioned throughput is exceeded, or an internal processing
     *             failure occurs. If a partial result is returned, the operation returns a value for
     *                 <code>UnprocessedKeys</code>. You can use this value to retry the operation starting
     *             with the next item to get.</p>
     *         <important>
     *             <p>If you request more than 100 items, <code>BatchGetItem</code> returns a
     *                     <code>ValidationException</code> with the message "Too many items requested for
     *                 the BatchGetItem call."</p>
     *         </important>
     *         <p>For example, if you ask to retrieve 100 items, but each individual item is 300 KB in
     *             size, the system returns 52 items (so as not to exceed the 16 MB limit). It also returns
     *             an appropriate <code>UnprocessedKeys</code> value so you can get the next page of
     *             results. If desired, your application can include its own logic to assemble the pages of
     *             results into one dataset.</p>
     *         <p>If <i>none</i> of the items can be processed due to insufficient
     *             provisioned throughput on all of the tables in the request, then
     *                 <code>BatchGetItem</code> returns a
     *                 <code>ProvisionedThroughputExceededException</code>. If <i>at least
     *                 one</i> of the items is successfully processed, then
     *                 <code>BatchGetItem</code> completes successfully, while returning the keys of the
     *             unread items in <code>UnprocessedKeys</code>.</p>
     *         <important>
     *             <p>If DynamoDB returns any unprocessed items, you should retry the batch operation on
     *                 those items. However, <i>we strongly recommend that you use an exponential
     *                     backoff algorithm</i>. If you retry the batch operation immediately, the
     *                 underlying read or write requests can still fail due to throttling on the individual
     *                 tables. If you delay the batch operation using exponential backoff, the individual
     *                 requests in the batch are much more likely to succeed.</p>
     *             <p>For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#BatchOperations">Batch Operations and Error Handling</a> in the <i>Amazon DynamoDB
     *                     Developer Guide</i>.</p>
     *         </important>
     *         <p>By default, <code>BatchGetItem</code> performs eventually consistent reads on every
     *             table in the request. If you want strongly consistent reads instead, you can set
     *                 <code>ConsistentRead</code> to <code>true</code> for any or all tables.</p>
     *         <p>In order to minimize response latency, <code>BatchGetItem</code> retrieves items in
     *             parallel.</p>
     *         <p>When designing your application, keep in mind that DynamoDB does not return items in
     *             any particular order. To help parse the response by item, include the primary key values
     *             for the items in your request in the <code>ProjectionExpression</code> parameter.</p>
     *         <p>If a requested item does not exist, it is not returned in the result. Requests for
     *             nonexistent items consume the minimum read capacity units according to the type of read.
     *             For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html#CapacityUnitCalculations">Working with Tables</a> in the <i>Amazon DynamoDB Developer
     *                 Guide</i>.</p>
     */
    batchGetItem(args: BatchGetItemCommandInput, options?: __HttpHandlerOptions): Promise<BatchGetItemCommandOutput>;
    batchGetItem(args: BatchGetItemCommandInput, cb: (err: any, data?: BatchGetItemCommandOutput) => void): void;
    batchGetItem(args: BatchGetItemCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: BatchGetItemCommandOutput) => void): void;
    /**
     * <p>The <code>BatchWriteItem</code> operation puts or deletes multiple items in one or
     *             more tables. A single call to <code>BatchWriteItem</code> can transmit up to 16MB of
     *             data over the network, consisting of up to 25 item put or delete operations. While
     *             individual items can be up to 400 KB once stored, it's important to note that an item's
     *             representation might be greater than 400KB while being sent in DynamoDB's JSON format
     *             for the API call. For more details on this distinction, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html">Naming Rules and Data Types</a>.</p>
     *         <note>
     *             <p>
     *                 <code>BatchWriteItem</code> cannot update items. If you perform a <code>BatchWriteItem</code>
     *                 operation on an existing item, that item's values will be overwritten by the
     *                 operation and it will appear like it was updated. To update items, we recommend you
     *                 use the <code>UpdateItem</code> action.</p>
     *         </note>
     *         <p>The individual <code>PutItem</code> and <code>DeleteItem</code> operations specified
     *             in <code>BatchWriteItem</code> are atomic; however <code>BatchWriteItem</code> as a
     *             whole is not. If any requested operations fail because the table's provisioned
     *             throughput is exceeded or an internal processing failure occurs, the failed operations
     *             are returned in the <code>UnprocessedItems</code> response parameter. You can
     *             investigate and optionally resend the requests. Typically, you would call
     *                 <code>BatchWriteItem</code> in a loop. Each iteration would check for unprocessed
     *             items and submit a new <code>BatchWriteItem</code> request with those unprocessed items
     *             until all items have been processed.</p>
     *         <p>If <i>none</i> of the items can be processed due to insufficient
     *             provisioned throughput on all of the tables in the request, then
     *                 <code>BatchWriteItem</code> returns a
     *                 <code>ProvisionedThroughputExceededException</code>.</p>
     *         <important>
     *             <p>If DynamoDB returns any unprocessed items, you should retry the batch operation on
     *                 those items. However, <i>we strongly recommend that you use an exponential
     *                     backoff algorithm</i>. If you retry the batch operation immediately, the
     *                 underlying read or write requests can still fail due to throttling on the individual
     *                 tables. If you delay the batch operation using exponential backoff, the individual
     *                 requests in the batch are much more likely to succeed.</p>
     *             <p>For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#Programming.Errors.BatchOperations">Batch Operations and Error Handling</a> in the <i>Amazon DynamoDB
     *                     Developer Guide</i>.</p>
     *         </important>
     *
     *         <p>With <code>BatchWriteItem</code>, you can efficiently write or delete large amounts of
     *             data, such as from Amazon EMR, or copy data from another database into DynamoDB. In
     *             order to improve performance with these large-scale operations,
     *                 <code>BatchWriteItem</code> does not behave in the same way as individual
     *                 <code>PutItem</code> and <code>DeleteItem</code> calls would. For example, you
     *             cannot specify conditions on individual put and delete requests, and
     *                 <code>BatchWriteItem</code> does not return deleted items in the response.</p>
     *         <p>If you use a programming language that supports concurrency, you can use threads to
     *             write items in parallel. Your application must include the necessary logic to manage the
     *             threads. With languages that don't support threading, you must update or delete the
     *             specified items one at a time. In both situations, <code>BatchWriteItem</code> performs
     *             the specified put and delete operations in parallel, giving you the power of the thread
     *             pool approach without having to introduce complexity into your application.</p>
     *         <p>Parallel processing reduces latency, but each specified put and delete request
     *             consumes the same number of write capacity units whether it is processed in parallel or
     *             not. Delete operations on nonexistent items consume one write capacity unit.</p>
     *         <p>If one or more of the following is true, DynamoDB rejects the entire batch write
     *             operation:</p>
     *         <ul>
     *             <li>
     *                 <p>One or more tables specified in the <code>BatchWriteItem</code> request does
     *                     not exist.</p>
     *             </li>
     *             <li>
     *                 <p>Primary key attributes specified on an item in the request do not match those
     *                     in the corresponding table's primary key schema.</p>
     *             </li>
     *             <li>
     *                 <p>You try to perform multiple operations on the same item in the same
     *                         <code>BatchWriteItem</code> request. For example, you cannot put and delete
     *                     the same item in the same <code>BatchWriteItem</code> request. </p>
     *             </li>
     *             <li>
     *                 <p> Your request contains at least two items with identical hash and range keys
     *                     (which essentially is two put operations). </p>
     *             </li>
     *             <li>
     *                 <p>There are more than 25 requests in the batch.</p>
     *             </li>
     *             <li>
     *                 <p>Any individual item in a batch exceeds 400 KB.</p>
     *             </li>
     *             <li>
     *                 <p>The total request size exceeds 16 MB.</p>
     *             </li>
     *          </ul>
     */
    batchWriteItem(args: BatchWriteItemCommandInput, options?: __HttpHandlerOptions): Promise<BatchWriteItemCommandOutput>;
    batchWriteItem(args: BatchWriteItemCommandInput, cb: (err: any, data?: BatchWriteItemCommandOutput) => void): void;
    batchWriteItem(args: BatchWriteItemCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: BatchWriteItemCommandOutput) => void): void;
    /**
     * <p>Creates a backup for an existing table.</p>
     *         <p> Each time you create an on-demand backup, the entire table data is backed up. There
     *             is no limit to the number of on-demand backups that can be taken. </p>
     *         <p> When you create an on-demand backup, a time marker of the request is cataloged, and
     *             the backup is created asynchronously, by applying all changes until the time of the
     *             request to the last full table snapshot. Backup requests are processed instantaneously
     *             and become available for restore within minutes. </p>
     *         <p>You can call <code>CreateBackup</code> at a maximum rate of 50 times per
     *             second.</p>
     *         <p>All backups in DynamoDB work without consuming any provisioned throughput on the
     *             table.</p>
     *         <p> If you submit a backup request on 2018-12-14 at 14:25:00, the backup is guaranteed to
     *             contain all data committed to the table up to 14:24:00, and data committed after
     *             14:26:00 will not be. The backup might contain data modifications made between 14:24:00
     *             and 14:26:00. On-demand backup does not support causal consistency. </p>
     *         <p> Along with data, the following are also included on the backups: </p>
     *         <ul>
     *             <li>
     *                 <p>Global secondary indexes (GSIs)</p>
     *             </li>
     *             <li>
     *                 <p>Local secondary indexes (LSIs)</p>
     *             </li>
     *             <li>
     *                 <p>Streams</p>
     *             </li>
     *             <li>
     *                 <p>Provisioned read and write capacity</p>
     *             </li>
     *          </ul>
     */
    createBackup(args: CreateBackupCommandInput, options?: __HttpHandlerOptions): Promise<CreateBackupCommandOutput>;
    createBackup(args: CreateBackupCommandInput, cb: (err: any, data?: CreateBackupCommandOutput) => void): void;
    createBackup(args: CreateBackupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateBackupCommandOutput) => void): void;
    /**
     * <p>Creates a global table from an existing table. A global table creates a replication
     *             relationship between two or more DynamoDB tables with the same table name in the
     *             provided Regions. </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>
     *
     *         <p>If you want to add a new replica table to a global table, each of the following
     *             conditions must be true:</p>
     *         <ul>
     *             <li>
     *                 <p>The table must have the same primary key as all of the other replicas.</p>
     *             </li>
     *             <li>
     *                 <p>The table must have the same name as all of the other replicas.</p>
     *             </li>
     *             <li>
     *                 <p>The table must have DynamoDB Streams enabled, with the stream containing both
     *                     the new and the old images of the item.</p>
     *             </li>
     *             <li>
     *                 <p>None of the replica tables in the global table can contain any data.</p>
     *             </li>
     *          </ul>
     *         <p> If global secondary indexes are specified, then the following conditions must also be
     *             met: </p>
     *         <ul>
     *             <li>
     *                 <p> The global secondary indexes must have the same name. </p>
     *             </li>
     *             <li>
     *                 <p> The global secondary indexes must have the same hash key and sort key (if
     *                     present). </p>
     *             </li>
     *          </ul>
     *         <p> If local secondary indexes are specified, then the following conditions must also be
     *             met: </p>
     *         <ul>
     *             <li>
     *                 <p> The local secondary indexes must have the same name. </p>
     *             </li>
     *             <li>
     *                 <p> The local secondary indexes must have the same hash key and sort key (if
     *                     present). </p>
     *             </li>
     *          </ul>
     *
     *         <important>
     *             <p> Write capacity settings should be set consistently across your replica tables and
     *                 secondary indexes. DynamoDB strongly recommends enabling auto scaling to manage the
     *                 write capacity settings for all of your global tables replicas and indexes. </p>
     *             <p> If you prefer to manage write capacity settings manually, you should provision
     *                 equal replicated write capacity units to your replica tables. You should also
     *                 provision equal replicated write capacity units to matching secondary indexes across
     *                 your global table. </p>
     *         </important>
     */
    createGlobalTable(args: CreateGlobalTableCommandInput, options?: __HttpHandlerOptions): Promise<CreateGlobalTableCommandOutput>;
    createGlobalTable(args: CreateGlobalTableCommandInput, cb: (err: any, data?: CreateGlobalTableCommandOutput) => void): void;
    createGlobalTable(args: CreateGlobalTableCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateGlobalTableCommandOutput) => void): void;
    /**
     * <p>The <code>CreateTable</code> operation adds a new table to your account. In an Amazon Web Services account, table names must be unique within each Region. That is, you can
     *             have two tables with same name if you create the tables in different Regions.</p>
     *         <p>
     *             <code>CreateTable</code> is an asynchronous operation. Upon receiving a
     *                 <code>CreateTable</code> request, DynamoDB immediately returns a response with a
     *                 <code>TableStatus</code> of <code>CREATING</code>. After the table is created,
     *             DynamoDB sets the <code>TableStatus</code> to <code>ACTIVE</code>. You can perform read
     *             and write operations only on an <code>ACTIVE</code> table. </p>
     *         <p>You can optionally define secondary indexes on the new table, as part of the
     *                 <code>CreateTable</code> operation. If you want to create multiple tables with
     *             secondary indexes on them, you must create the tables sequentially. Only one table with
     *             secondary indexes can be in the <code>CREATING</code> state at any given time.</p>
     *         <p>You can use the <code>DescribeTable</code> action to check the table status.</p>
     */
    createTable(args: CreateTableCommandInput, options?: __HttpHandlerOptions): Promise<CreateTableCommandOutput>;
    createTable(args: CreateTableCommandInput, cb: (err: any, data?: CreateTableCommandOutput) => void): void;
    createTable(args: CreateTableCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateTableCommandOutput) => void): void;
    /**
     * <p>Deletes an existing backup of a table.</p>
     *         <p>You can call <code>DeleteBackup</code> at a maximum rate of 10 times per
     *             second.</p>
     */
    deleteBackup(args: DeleteBackupCommandInput, options?: __HttpHandlerOptions): Promise<DeleteBackupCommandOutput>;
    deleteBackup(args: DeleteBackupCommandInput, cb: (err: any, data?: DeleteBackupCommandOutput) => void): void;
    deleteBackup(args: DeleteBackupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteBackupCommandOutput) => void): void;
    /**
     * <p>Deletes a single item in a table by primary key. You can perform a conditional delete
     *             operation that deletes the item if it exists, or if it has an expected attribute
     *             value.</p>
     *         <p>In addition to deleting an item, you can also return the item's attribute values in
     *             the same operation, using the <code>ReturnValues</code> parameter.</p>
     *         <p>Unless you specify conditions, the <code>DeleteItem</code> is an idempotent operation;
     *             running it multiple times on the same item or attribute does <i>not</i>
     *             result in an error response.</p>
     *         <p>Conditional deletes are useful for deleting items only if specific conditions are met.
     *             If those conditions are met, DynamoDB performs the delete. Otherwise, the item is not
     *             deleted.</p>
     */
    deleteItem(args: DeleteItemCommandInput, options?: __HttpHandlerOptions): Promise<DeleteItemCommandOutput>;
    deleteItem(args: DeleteItemCommandInput, cb: (err: any, data?: DeleteItemCommandOutput) => void): void;
    deleteItem(args: DeleteItemCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteItemCommandOutput) => void): void;
    /**
     * <p>The <code>DeleteTable</code> operation deletes a table and all of its items. After a
     *                 <code>DeleteTable</code> request, the specified table is in the
     *                 <code>DELETING</code> state until DynamoDB completes the deletion. If the table is
     *             in the <code>ACTIVE</code> state, you can delete it. If a table is in
     *                 <code>CREATING</code> or <code>UPDATING</code> states, then DynamoDB returns a
     *                 <code>ResourceInUseException</code>. If the specified table does not exist, DynamoDB
     *             returns a <code>ResourceNotFoundException</code>. If table is already in the
     *                 <code>DELETING</code> state, no error is returned. </p>
     *         <note>
     *             <p>DynamoDB might continue to accept data read and write operations, such as
     *                     <code>GetItem</code> and <code>PutItem</code>, on a table in the
     *                     <code>DELETING</code> state until the table deletion is complete.</p>
     *         </note>
     *         <p>When you delete a table, any indexes on that table are also deleted.</p>
     *         <p>If you have DynamoDB Streams enabled on the table, then the corresponding stream on
     *             that table goes into the <code>DISABLED</code> state, and the stream is automatically
     *             deleted after 24 hours.</p>
     *
     *         <p>Use the <code>DescribeTable</code> action to check the status of the table. </p>
     */
    deleteTable(args: DeleteTableCommandInput, options?: __HttpHandlerOptions): Promise<DeleteTableCommandOutput>;
    deleteTable(args: DeleteTableCommandInput, cb: (err: any, data?: DeleteTableCommandOutput) => void): void;
    deleteTable(args: DeleteTableCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteTableCommandOutput) => void): void;
    /**
     * <p>Describes an existing backup of a table.</p>
     *         <p>You can call <code>DescribeBackup</code> at a maximum rate of 10 times per
     *             second.</p>
     */
    describeBackup(args: DescribeBackupCommandInput, options?: __HttpHandlerOptions): Promise<DescribeBackupCommandOutput>;
    describeBackup(args: DescribeBackupCommandInput, cb: (err: any, data?: DescribeBackupCommandOutput) => void): void;
    describeBackup(args: DescribeBackupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeBackupCommandOutput) => void): void;
    /**
     * <p>Checks the status of continuous backups and point in time recovery on the specified
     *             table. Continuous backups are <code>ENABLED</code> on all tables at table creation. If
     *             point in time recovery is enabled, <code>PointInTimeRecoveryStatus</code> will be set to
     *             ENABLED.</p>
     *         <p> After continuous backups and point in time recovery are enabled, you can restore to
     *             any point in time within <code>EarliestRestorableDateTime</code> and
     *                 <code>LatestRestorableDateTime</code>. </p>
     *         <p>
     *             <code>LatestRestorableDateTime</code> is typically 5 minutes before the current time.
     *             You can restore your table to any point in time during the last 35 days. </p>
     *         <p>You can call <code>DescribeContinuousBackups</code> at a maximum rate of 10 times per
     *             second.</p>
     */
    describeContinuousBackups(args: DescribeContinuousBackupsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeContinuousBackupsCommandOutput>;
    describeContinuousBackups(args: DescribeContinuousBackupsCommandInput, cb: (err: any, data?: DescribeContinuousBackupsCommandOutput) => void): void;
    describeContinuousBackups(args: DescribeContinuousBackupsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeContinuousBackupsCommandOutput) => void): void;
    /**
     * <p>Returns information about contributor insights, for a given table or global secondary
     *             index.</p>
     */
    describeContributorInsights(args: DescribeContributorInsightsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeContributorInsightsCommandOutput>;
    describeContributorInsights(args: DescribeContributorInsightsCommandInput, cb: (err: any, data?: DescribeContributorInsightsCommandOutput) => void): void;
    describeContributorInsights(args: DescribeContributorInsightsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeContributorInsightsCommandOutput) => void): void;
    /**
     * <p>Returns the regional endpoint information.</p>
     */
    describeEndpoints(args: DescribeEndpointsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeEndpointsCommandOutput>;
    describeEndpoints(args: DescribeEndpointsCommandInput, cb: (err: any, data?: DescribeEndpointsCommandOutput) => void): void;
    describeEndpoints(args: DescribeEndpointsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeEndpointsCommandOutput) => void): void;
    /**
     * <p>Describes an existing table export.</p>
     */
    describeExport(args: DescribeExportCommandInput, options?: __HttpHandlerOptions): Promise<DescribeExportCommandOutput>;
    describeExport(args: DescribeExportCommandInput, cb: (err: any, data?: DescribeExportCommandOutput) => void): void;
    describeExport(args: DescribeExportCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeExportCommandOutput) => void): void;
    /**
     * <p>Returns information about the specified global table.</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. If you are using global tables <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version
     *                     2019.11.21</a> you can use <a href="https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html">DescribeTable</a> instead.</p>
     *         </note>
     */
    describeGlobalTable(args: DescribeGlobalTableCommandInput, options?: __HttpHandlerOptions): Promise<DescribeGlobalTableCommandOutput>;
    describeGlobalTable(args: DescribeGlobalTableCommandInput, cb: (err: any, data?: DescribeGlobalTableCommandOutput) => void): void;
    describeGlobalTable(args: DescribeGlobalTableCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeGlobalTableCommandOutput) => void): void;
    /**
     * <p>Describes Region-specific settings for a global table.</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>
     */
    describeGlobalTableSettings(args: DescribeGlobalTableSettingsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeGlobalTableSettingsCommandOutput>;
    describeGlobalTableSettings(args: DescribeGlobalTableSettingsCommandInput, cb: (err: any, data?: DescribeGlobalTableSettingsCommandOutput) => void): void;
    describeGlobalTableSettings(args: DescribeGlobalTableSettingsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeGlobalTableSettingsCommandOutput) => void): void;
    /**
     * <p> Represents the properties of the import. </p>
     */
    describeImport(args: DescribeImportCommandInput, options?: __HttpHandlerOptions): Promise<DescribeImportCommandOutput>;
    describeImport(args: DescribeImportCommandInput, cb: (err: any, data?: DescribeImportCommandOutput) => void): void;
    describeImport(args: DescribeImportCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeImportCommandOutput) => void): void;
    /**
     * <p>Returns information about the status of Kinesis streaming.</p>
     */
    describeKinesisStreamingDestination(args: DescribeKinesisStreamingDestinationCommandInput, options?: __HttpHandlerOptions): Promise<DescribeKinesisStreamingDestinationCommandOutput>;
    describeKinesisStreamingDestination(args: DescribeKinesisStreamingDestinationCommandInput, cb: (err: any, data?: DescribeKinesisStreamingDestinationCommandOutput) => void): void;
    describeKinesisStreamingDestination(args: DescribeKinesisStreamingDestinationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeKinesisStreamingDestinationCommandOutput) => void): void;
    /**
     * <p>Returns the current provisioned-capacity quotas for your Amazon Web Services account in
     *             a Region, both for the Region as a whole and for any one DynamoDB table that you create
     *             there.</p>
     *         <p>When you establish an Amazon Web Services account, the account has initial quotas on
     *             the maximum read capacity units and write capacity units that you can provision across
     *             all of your DynamoDB tables in a given Region. Also, there are per-table
     *             quotas that apply when you create a table there. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Service,
     *                 Account, and Table Quotas</a> page in the <i>Amazon DynamoDB
     *                 Developer Guide</i>.</p>
     *
     *         <p>Although you can increase these quotas by filing a case at <a href="https://console.aws.amazon.com/support/home#/">Amazon Web Services Support Center</a>, obtaining the
     *             increase is not instantaneous. The <code>DescribeLimits</code> action lets you write
     *             code to compare the capacity you are currently using to those quotas imposed by your
     *             account so that you have enough time to apply for an increase before you hit a
     *             quota.</p>
     *
     *         <p>For example, you could use one of the Amazon Web Services SDKs to do the
     *             following:</p>
     *
     *         <ol>
     *             <li>
     *                 <p>Call <code>DescribeLimits</code> for a particular Region to obtain your
     *                     current account quotas on provisioned capacity there.</p>
     *             </li>
     *             <li>
     *                 <p>Create a variable to hold the aggregate read capacity units provisioned for
     *                     all your tables in that Region, and one to hold the aggregate write capacity
     *                     units. Zero them both.</p>
     *             </li>
     *             <li>
     *                 <p>Call <code>ListTables</code> to obtain a list of all your DynamoDB
     *                     tables.</p>
     *             </li>
     *             <li>
     *                 <p>For each table name listed by <code>ListTables</code>, do the
     *                     following:</p>
     *                 <ul>
     *                   <li>
     *                         <p>Call <code>DescribeTable</code> with the table name.</p>
     *                     </li>
     *                   <li>
     *                         <p>Use the data returned by <code>DescribeTable</code> to add the read
     *                             capacity units and write capacity units provisioned for the table itself
     *                             to your variables.</p>
     *                     </li>
     *                   <li>
     *                         <p>If the table has one or more global secondary indexes (GSIs), loop
     *                             over these GSIs and add their provisioned capacity values to your
     *                             variables as well.</p>
     *                     </li>
     *                </ul>
     *             </li>
     *             <li>
     *                 <p>Report the account quotas for that Region returned by
     *                         <code>DescribeLimits</code>, along with the total current provisioned
     *                     capacity levels you have calculated.</p>
     *             </li>
     *          </ol>
     *
     *         <p>This will let you see whether you are getting close to your account-level
     *             quotas.</p>
     *         <p>The per-table quotas apply only when you are creating a new table. They restrict the
     *             sum of the provisioned capacity of the new table itself and all its global secondary
     *             indexes.</p>
     *         <p>For existing tables and their GSIs, DynamoDB doesn't let you increase provisioned
     *             capacity extremely rapidly, but the only quota that applies is that the aggregate
     *             provisioned capacity over all your tables and GSIs cannot exceed either of the
     *             per-account quotas.</p>
     *         <note>
     *             <p>
     *                 <code>DescribeLimits</code> should only be called periodically. You can expect
     *                 throttling errors if you call it more than once in a minute.</p>
     *         </note>
     *         <p>The <code>DescribeLimits</code> Request element has no content.</p>
     */
    describeLimits(args: DescribeLimitsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeLimitsCommandOutput>;
    describeLimits(args: DescribeLimitsCommandInput, cb: (err: any, data?: DescribeLimitsCommandOutput) => void): void;
    describeLimits(args: DescribeLimitsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeLimitsCommandOutput) => void): void;
    /**
     * <p>Returns information about the table, including the current status of the table, when
     *             it was created, the primary key schema, and any indexes on the table.</p>
     *         <note>
     *             <p>If you issue a <code>DescribeTable</code> request immediately after a
     *                     <code>CreateTable</code> request, DynamoDB might return a
     *                     <code>ResourceNotFoundException</code>. This is because
     *                     <code>DescribeTable</code> uses an eventually consistent query, and the metadata
     *                 for your table might not be available at that moment. Wait for a few seconds, and
     *                 then try the <code>DescribeTable</code> request again.</p>
     *         </note>
     */
    describeTable(args: DescribeTableCommandInput, options?: __HttpHandlerOptions): Promise<DescribeTableCommandOutput>;
    describeTable(args: DescribeTableCommandInput, cb: (err: any, data?: DescribeTableCommandOutput) => void): void;
    describeTable(args: DescribeTableCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeTableCommandOutput) => void): void;
    /**
     * <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>
     */
    describeTableReplicaAutoScaling(args: DescribeTableReplicaAutoScalingCommandInput, options?: __HttpHandlerOptions): Promise<DescribeTableReplicaAutoScalingCommandOutput>;
    describeTableReplicaAutoScaling(args: DescribeTableReplicaAutoScalingCommandInput, cb: (err: any, data?: DescribeTableReplicaAutoScalingCommandOutput) => void): void;
    describeTableReplicaAutoScaling(args: DescribeTableReplicaAutoScalingCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeTableReplicaAutoScalingCommandOutput) => void): void;
    /**
     * <p>Gives a description of the Time to Live (TTL) status on the specified table. </p>
     */
    describeTimeToLive(args: DescribeTimeToLiveCommandInput, options?: __HttpHandlerOptions): Promise<DescribeTimeToLiveCommandOutput>;
    describeTimeToLive(args: DescribeTimeToLiveCommandInput, cb: (err: any, data?: DescribeTimeToLiveCommandOutput) => void): void;
    describeTimeToLive(args: DescribeTimeToLiveCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeTimeToLiveCommandOutput) => void): void;
    /**
     * <p>Stops replication from the DynamoDB table to the Kinesis data stream. This is done
     *             without deleting either of the resources.</p>
     */
    disableKinesisStreamingDestination(args: DisableKinesisStreamingDestinationCommandInput, options?: __HttpHandlerOptions): Promise<DisableKinesisStreamingDestinationCommandOutput>;
    disableKinesisStreamingDestination(args: DisableKinesisStreamingDestinationCommandInput, cb: (err: any, data?: DisableKinesisStreamingDestinationCommandOutput) => void): void;
    disableKinesisStreamingDestination(args: DisableKinesisStreamingDestinationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DisableKinesisStreamingDestinationCommandOutput) => void): void;
    /**
     * <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>
     */
    enableKinesisStreamingDestination(args: EnableKinesisStreamingDestinationCommandInput, options?: __HttpHandlerOptions): Promise<EnableKinesisStreamingDestinationCommandOutput>;
    enableKinesisStreamingDestination(args: EnableKinesisStreamingDestinationCommandInput, cb: (err: any, data?: EnableKinesisStreamingDestinationCommandOutput) => void): void;
    enableKinesisStreamingDestination(args: EnableKinesisStreamingDestinationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: EnableKinesisStreamingDestinationCommandOutput) => void): void;
    /**
     * <p>This operation allows you to perform reads and singleton writes on data stored in
     *             DynamoDB, using PartiQL.</p>
     *         <p>For PartiQL reads (<code>SELECT</code> statement), if the total number of processed
     *             items exceeds the maximum dataset size limit of 1 MB, the read stops and results are
     *             returned to the user as a <code>LastEvaluatedKey</code> value to continue the read in a
     *             subsequent operation. If the filter criteria in <code>WHERE</code> clause does not match
     *             any data, the read will return an empty result set.</p>
     *         <p>A single <code>SELECT</code> statement response can return up to the maximum number of
     *             items (if using the Limit parameter) or a maximum of 1 MB of data (and then apply any
     *             filtering to the results using <code>WHERE</code> clause). If
     *                 <code>LastEvaluatedKey</code> is present in the response, you need to paginate the
     *             result set.</p>
     */
    executeStatement(args: ExecuteStatementCommandInput, options?: __HttpHandlerOptions): Promise<ExecuteStatementCommandOutput>;
    executeStatement(args: ExecuteStatementCommandInput, cb: (err: any, data?: ExecuteStatementCommandOutput) => void): void;
    executeStatement(args: ExecuteStatementCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ExecuteStatementCommandOutput) => void): void;
    /**
     * <p>This operation allows you to perform transactional reads or writes on data stored in
     *             DynamoDB, using PartiQL.</p>
     *         <note>
     *             <p>The entire transaction must consist of either read statements or write statements,
     *                 you cannot mix both in one transaction. The EXISTS function is an exception and can
     *                 be used to check the condition of specific attributes of the item in a similar
     *                 manner to <code>ConditionCheck</code> in the <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transaction-apis.html#transaction-apis-txwriteitems">TransactWriteItems</a> API.</p>
     *         </note>
     */
    executeTransaction(args: ExecuteTransactionCommandInput, options?: __HttpHandlerOptions): Promise<ExecuteTransactionCommandOutput>;
    executeTransaction(args: ExecuteTransactionCommandInput, cb: (err: any, data?: ExecuteTransactionCommandOutput) => void): void;
    executeTransaction(args: ExecuteTransactionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ExecuteTransactionCommandOutput) => void): void;
    /**
     * <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>
     */
    exportTableToPointInTime(args: ExportTableToPointInTimeCommandInput, options?: __HttpHandlerOptions): Promise<ExportTableToPointInTimeCommandOutput>;
    exportTableToPointInTime(args: ExportTableToPointInTimeCommandInput, cb: (err: any, data?: ExportTableToPointInTimeCommandOutput) => void): void;
    exportTableToPointInTime(args: ExportTableToPointInTimeCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ExportTableToPointInTimeCommandOutput) => void): void;
    /**
     * <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>
     */
    getItem(args: GetItemCommandInput, options?: __HttpHandlerOptions): Promise<GetItemCommandOutput>;
    getItem(args: GetItemCommandInput, cb: (err: any, data?: GetItemCommandOutput) => void): void;
    getItem(args: GetItemCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetItemCommandOutput) => void): void;
    /**
     * <p> Imports table data from an S3 bucket. </p>
     */
    importTable(args: ImportTableCommandInput, options?: __HttpHandlerOptions): Promise<ImportTableCommandOutput>;
    importTable(args: ImportTableCommandInput, cb: (err: any, data?: ImportTableCommandOutput) => void): void;
    importTable(args: ImportTableCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ImportTableCommandOutput) => void): void;
    /**
     * <p>List backups associated with an Amazon Web Services 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>
     */
    listBackups(args: ListBackupsCommandInput, options?: __HttpHandlerOptions): Promise<ListBackupsCommandOutput>;
    listBackups(args: ListBackupsCommandInput, cb: (err: any, data?: ListBackupsCommandOutput) => void): void;
    listBackups(args: ListBackupsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListBackupsCommandOutput) => void): void;
    /**
     * <p>Returns a list of ContributorInsightsSummary for a table and all its global secondary
     *             indexes.</p>
     */
    listContributorInsights(args: ListContributorInsightsCommandInput, options?: __HttpHandlerOptions): Promise<ListContributorInsightsCommandOutput>;
    listContributorInsights(args: ListContributorInsightsCommandInput, cb: (err: any, data?: ListContributorInsightsCommandOutput) => void): void;
    listContributorInsights(args: ListContributorInsightsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListContributorInsightsCommandOutput) => void): void;
    /**
     * <p>Lists completed exports within the past 90 days.</p>
     */
    listExports(args: ListExportsCommandInput, options?: __HttpHandlerOptions): Promise<ListExportsCommandOutput>;
    listExports(args: ListExportsCommandInput, cb: (err: any, data?: ListExportsCommandOutput) => void): void;
    listExports(args: ListExportsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListExportsCommandOutput) => void): void;
    /**
     * <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>
     */
    listGlobalTables(args: ListGlobalTablesCommandInput, options?: __HttpHandlerOptions): Promise<ListGlobalTablesCommandOutput>;
    listGlobalTables(args: ListGlobalTablesCommandInput, cb: (err: any, data?: ListGlobalTablesCommandOutput) => void): void;
    listGlobalTables(args: ListGlobalTablesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListGlobalTablesCommandOutput) => void): void;
    /**
     * <p> Lists completed imports within the past 90 days. </p>
     */
    listImports(args: ListImportsCommandInput, options?: __HttpHandlerOptions): Promise<ListImportsCommandOutput>;
    listImports(args: ListImportsCommandInput, cb: (err: any, data?: ListImportsCommandOutput) => void): void;
    listImports(args: ListImportsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListImportsCommandOutput) => void): void;
    /**
     * <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>
     */
    listTables(args: ListTablesCommandInput, options?: __HttpHandlerOptions): Promise<ListTablesCommandOutput>;
    listTables(args: ListTablesCommandInput, cb: (err: any, data?: ListTablesCommandOutput) => void): void;
    listTables(args: ListTablesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTablesCommandOutput) => void): void;
    /**
     * <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>
     */
    listTagsOfResource(args: ListTagsOfResourceCommandInput, options?: __HttpHandlerOptions): Promise<ListTagsOfResourceCommandOutput>;
    listTagsOfResource(args: ListTagsOfResourceCommandInput, cb: (err: any, data?: ListTagsOfResourceCommandOutput) => void): void;
    listTagsOfResource(args: ListTagsOfResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTagsOfResourceCommandOutput) => void): void;
    /**
     * <p>Creates a new item, or replaces an old item with a new item. If an item that has the
     *             same primary key as the new item already exists in the specified table, the new item
     *             completely replaces the existing item. You can perform a conditional put operation (add
     *             a new item if one with the specified primary key doesn't exist), or replace an existing
     *             item if it has certain attribute values. You can return the item's attribute values in
     *             the same operation, using the <code>ReturnValues</code> parameter.</p>
     *
     *         <p>When you add an item, the primary key attributes are the only required attributes.
     *             </p>
     *         <p>Empty String and Binary attribute values are allowed. Attribute values of type String
     *             and Binary must have a length greater than zero if the attribute is used as a key
     *             attribute for a table or index. Set type attributes cannot be empty. </p>
     *         <p>Invalid Requests with empty values will be rejected with a
     *                 <code>ValidationException</code> exception.</p>
     *         <note>
     *             <p>To prevent a new item from replacing an existing item, use a conditional
     *                 expression that contains the <code>attribute_not_exists</code> function with the
     *                 name of the attribute being used as the partition key for the table. Since every
     *                 record must contain that attribute, the <code>attribute_not_exists</code> function
     *                 will only succeed if no matching item exists.</p>
     *         </note>
     *         <p>For more information about <code>PutItem</code>, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html">Working with
     *                 Items</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
     */
    putItem(args: PutItemCommandInput, options?: __HttpHandlerOptions): Promise<PutItemCommandOutput>;
    putItem(args: PutItemCommandInput, cb: (err: any, data?: PutItemCommandOutput) => void): void;
    putItem(args: PutItemCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutItemCommandOutput) => void): void;
    /**
     * <p>You must provide the name of the partition key attribute and a single value for that
     *             attribute. <code>Query</code> returns all items with that partition key value.
     *             Optionally, you can provide a sort key attribute and use a comparison operator to refine
     *             the search results.</p>
     *
     *         <p>Use the <code>KeyConditionExpression</code> parameter to provide a specific value for
     *             the partition key. The <code>Query</code> operation will return all of the items from
     *             the table or index with that partition key value. You can optionally narrow the scope of
     *             the <code>Query</code> operation by specifying a sort key value and a comparison
     *             operator in <code>KeyConditionExpression</code>. To further refine the
     *                 <code>Query</code> results, you can optionally provide a
     *                 <code>FilterExpression</code>. A <code>FilterExpression</code> determines which
     *             items within the results should be returned to you. All of the other results are
     *             discarded. </p>
     *         <p> A <code>Query</code> operation always returns a result set. If no matching items are
     *             found, the result set will be empty. Queries that do not return results consume the
     *             minimum number of read capacity units for that type of read operation. </p>
     *         <note>
     *             <p> DynamoDB calculates the number of read capacity units consumed based on item
     *                 size, not on the amount of data that is returned to an application. The number of
     *                 capacity units consumed will be the same whether you request all of the attributes
     *                 (the default behavior) or just some of them (using a projection expression). The
     *                 number will also be the same whether or not you use a <code>FilterExpression</code>.
     *             </p>
     *         </note>
     *         <p>
     *             <code>Query</code> results are always sorted by the sort key value. If the data type of
     *             the sort key is Number, the results are returned in numeric order; otherwise, the
     *             results are returned in order of UTF-8 bytes. By default, the sort order is ascending.
     *             To reverse the order, set the <code>ScanIndexForward</code> parameter to false. </p>
     *         <p> A single <code>Query</code> operation will read up to the maximum number of items set
     *             (if using the <code>Limit</code> parameter) or a maximum of 1 MB of data and then apply
     *             any filtering to the results using <code>FilterExpression</code>. If
     *                 <code>LastEvaluatedKey</code> is present in the response, you will need to paginate
     *             the result set. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html#Query.Pagination">Paginating
     *                 the Results</a> in the <i>Amazon DynamoDB Developer Guide</i>. </p>
     *         <p>
     *             <code>FilterExpression</code> is applied after a <code>Query</code> finishes, but before
     *             the results are returned. A <code>FilterExpression</code> cannot contain partition key
     *             or sort key attributes. You need to specify those attributes in the
     *                 <code>KeyConditionExpression</code>. </p>
     *         <note>
     *             <p> A <code>Query</code> operation can return an empty result set and a
     *                     <code>LastEvaluatedKey</code> if all the items read for the page of results are
     *                 filtered out. </p>
     *         </note>
     *         <p>You can query a table, a local secondary index, or a global secondary index. For a
     *             query on a table or on a local secondary index, you can set the
     *                 <code>ConsistentRead</code> parameter to <code>true</code> and obtain a strongly
     *             consistent result. Global secondary indexes support eventually consistent reads only, so
     *             do not specify <code>ConsistentRead</code> when querying a global secondary
     *             index.</p>
     */
    query(args: QueryCommandInput, options?: __HttpHandlerOptions): Promise<QueryCommandOutput>;
    query(args: QueryCommandInput, cb: (err: any, data?: QueryCommandOutput) => void): void;
    query(args: QueryCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: QueryCommandOutput) => void): void;
    /**
     * <p>Creates a new table from an existing backup. Any number of users can execute up to 4
     *             concurrent restores (any type of restore) in a given account. </p>
     *         <p>You can call <code>RestoreTableFromBackup</code> at a maximum rate of 10 times per
     *             second.</p>
     *         <p>You must manually set up the following on the restored table:</p>
     *         <ul>
     *             <li>
     *                 <p>Auto scaling policies</p>
     *             </li>
     *             <li>
     *                 <p>IAM policies</p>
     *             </li>
     *             <li>
     *                 <p>Amazon CloudWatch metrics and alarms</p>
     *             </li>
     *             <li>
     *                 <p>Tags</p>
     *             </li>
     *             <li>
     *                 <p>Stream settings</p>
     *             </li>
     *             <li>
     *                 <p>Time to Live (TTL) settings</p>
     *             </li>
     *          </ul>
     */
    restoreTableFromBackup(args: RestoreTableFromBackupCommandInput, options?: __HttpHandlerOptions): Promise<RestoreTableFromBackupCommandOutput>;
    restoreTableFromBackup(args: RestoreTableFromBackupCommandInput, cb: (err: any, data?: RestoreTableFromBackupCommandOutput) => void): void;
    restoreTableFromBackup(args: RestoreTableFromBackupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: RestoreTableFromBackupCommandOutput) => void): void;
    /**
     * <p>Restores the specified table to the specified point in time within
     *                 <code>EarliestRestorableDateTime</code> and <code>LatestRestorableDateTime</code>.
     *             You can restore your table to any point in time during the last 35 days. Any number of
     *             users can execute up to 4 concurrent restores (any type of restore) in a given account. </p>
     *         <p> When you restore using point in time recovery, DynamoDB restores your table data to
     *             the state based on the selected date and time (day:hour:minute:second) to a new table. </p>
     *         <p> Along with data, the following are also included on the new restored table using
     *             point in time recovery: </p>
     *         <ul>
     *             <li>
     *                 <p>Global secondary indexes (GSIs)</p>
     *             </li>
     *             <li>
     *                 <p>Local secondary indexes (LSIs)</p>
     *             </li>
     *             <li>
     *                 <p>Provisioned read and write capacity</p>
     *             </li>
     *             <li>
     *                 <p>Encryption settings</p>
     *                 <important>
     *                     <p> All these settings come from the current settings of the source table at
     *                         the time of restore. </p>
     *                 </important>
     *             </li>
     *          </ul>
     *
     *         <p>You must manually set up the following on the restored table:</p>
     *         <ul>
     *             <li>
     *                 <p>Auto scaling policies</p>
     *             </li>
     *             <li>
     *                 <p>IAM policies</p>
     *             </li>
     *             <li>
     *                 <p>Amazon CloudWatch metrics and alarms</p>
     *             </li>
     *             <li>
     *                 <p>Tags</p>
     *             </li>
     *             <li>
     *                 <p>Stream settings</p>
     *             </li>
     *             <li>
     *                 <p>Time to Live (TTL) settings</p>
     *             </li>
     *             <li>
     *                 <p>Point in time recovery settings</p>
     *             </li>
     *          </ul>
     */
    restoreTableToPointInTime(args: RestoreTableToPointInTimeCommandInput, options?: __HttpHandlerOptions): Promise<RestoreTableToPointInTimeCommandOutput>;
    restoreTableToPointInTime(args: RestoreTableToPointInTimeCommandInput, cb: (err: any, data?: RestoreTableToPointInTimeCommandOutput) => void): void;
    restoreTableToPointInTime(args: RestoreTableToPointInTimeCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: RestoreTableToPointInTimeCommandOutput) => void): void;
    /**
     * <p>The <code>Scan</code> operation returns one or more items and item attributes by
     *             accessing every item in a table or a secondary index. To have DynamoDB return fewer
     *             items, you can provide a <code>FilterExpression</code> operation.</p>
     *         <p>If the total number of scanned items exceeds the maximum dataset size limit of 1 MB,
     *             the scan stops and results are returned to the user as a <code>LastEvaluatedKey</code>
     *             value to continue the scan in a subsequent operation. The results also include the
     *             number of items exceeding the limit. A scan can result in no table data meeting the
     *             filter criteria. </p>
     *         <p>A single <code>Scan</code> operation reads up to the maximum number of items set (if
     *             using the <code>Limit</code> parameter) or a maximum of 1 MB of data and then apply any
     *             filtering to the results using <code>FilterExpression</code>. If
     *                 <code>LastEvaluatedKey</code> is present in the response, you need to paginate the
     *             result set. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html#Scan.Pagination">Paginating the
     *                 Results</a> in the <i>Amazon DynamoDB Developer Guide</i>. </p>
     *         <p>
     *             <code>Scan</code> operations proceed sequentially; however, for faster performance on
     *             a large table or secondary index, applications can request a parallel <code>Scan</code>
     *             operation by providing the <code>Segment</code> and <code>TotalSegments</code>
     *             parameters. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html#Scan.ParallelScan">Parallel
     *                 Scan</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
     *         <p>
     *             <code>Scan</code> uses eventually consistent reads when accessing the data in a table;
     *             therefore, the result set might not include the changes to data in the table immediately
     *             before the operation began. If you need a consistent copy of the data, as of the time
     *             that the <code>Scan</code> begins, you can set the <code>ConsistentRead</code> parameter
     *             to <code>true</code>.</p>
     */
    scan(args: ScanCommandInput, options?: __HttpHandlerOptions): Promise<ScanCommandOutput>;
    scan(args: ScanCommandInput, cb: (err: any, data?: ScanCommandOutput) => void): void;
    scan(args: ScanCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ScanCommandOutput) => void): void;
    /**
     * <p>Associate a set of tags with an Amazon DynamoDB resource. You can then activate these
     *             user-defined tags so that they appear on the Billing and Cost Management console for
     *             cost allocation tracking. You can call TagResource up to five 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>
     */
    tagResource(args: TagResourceCommandInput, options?: __HttpHandlerOptions): Promise<TagResourceCommandOutput>;
    tagResource(args: TagResourceCommandInput, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
    tagResource(args: TagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
    /**
     * <p>
     *             <code>TransactGetItems</code> is a synchronous operation that atomically retrieves
     *             multiple items from one or more tables (but not from indexes) in a single account and
     *             Region. A <code>TransactGetItems</code> call can contain up to 100
     *                 <code>TransactGetItem</code> objects, each of which contains a <code>Get</code>
     *             structure that specifies an item to retrieve from a table in the account and Region. A
     *             call to <code>TransactGetItems</code> cannot retrieve items from tables in more than one
     *                 Amazon Web Services account or Region. The aggregate size of the items in the
     *             transaction cannot exceed 4 MB.</p>
     *         <p>DynamoDB rejects the entire <code>TransactGetItems</code> request if any of
     *             the following is true:</p>
     *         <ul>
     *             <li>
     *                 <p>A conflicting operation is in the process of updating an item to be
     *                     read.</p>
     *             </li>
     *             <li>
     *                 <p>There is insufficient provisioned capacity for the transaction to be
     *                     completed.</p>
     *             </li>
     *             <li>
     *                 <p>There is a user error, such as an invalid data format.</p>
     *             </li>
     *             <li>
     *                 <p>The aggregate size of the items in the transaction cannot exceed 4 MB.</p>
     *             </li>
     *          </ul>
     */
    transactGetItems(args: TransactGetItemsCommandInput, options?: __HttpHandlerOptions): Promise<TransactGetItemsCommandOutput>;
    transactGetItems(args: TransactGetItemsCommandInput, cb: (err: any, data?: TransactGetItemsCommandOutput) => void): void;
    transactGetItems(args: TransactGetItemsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TransactGetItemsCommandOutput) => void): void;
    /**
     * <p>
     *             <code>TransactWriteItems</code> is a synchronous write operation that groups up to 100
     *             action requests. These actions can target items in different tables, but not in
     *             different Amazon Web Services accounts or Regions, and no two actions can target the same
     *             item. For example, you cannot both <code>ConditionCheck</code> and <code>Update</code>
     *             the same item. The aggregate size of the items in the transaction cannot exceed 4
     *             MB.</p>
     *
     *         <p>The actions are completed atomically so that either all of them succeed, or all of
     *             them fail. They are defined by the following objects:</p>
     *
     *         <ul>
     *             <li>
     *                 <p>
     *                   <code>Put</code>  —   Initiates a <code>PutItem</code>
     *                     operation to write a new item. This structure specifies the primary key of the
     *                     item to be written, the name of the table to write it in, an optional condition
     *                     expression that must be satisfied for the write to succeed, a list of the item's
     *                     attributes, and a field indicating whether to retrieve the item's attributes if
     *                     the condition is not met.</p>
     *             </li>
     *             <li>
     *                 <p>
     *                   <code>Update</code>  —   Initiates an <code>UpdateItem</code>
     *                     operation to update an existing item. This structure specifies the primary key
     *                     of the item to be updated, the name of the table where it resides, an optional
     *                     condition expression that must be satisfied for the update to succeed, an
     *                     expression that defines one or more attributes to be updated, and a field
     *                     indicating whether to retrieve the item's attributes if the condition is not
     *                     met.</p>
     *             </li>
     *             <li>
     *                 <p>
     *                   <code>Delete</code>  —   Initiates a <code>DeleteItem</code>
     *                     operation to delete an existing item. This structure specifies the primary key
     *                     of the item to be deleted, the name of the table where it resides, an optional
     *                     condition expression that must be satisfied for the deletion to succeed, and a
     *                     field indicating whether to retrieve the item's attributes if the condition is
     *                     not met.</p>
     *             </li>
     *             <li>
     *                 <p>
     *                   <code>ConditionCheck</code>  —   Applies a condition to an item
     *                     that is not being modified by the transaction. This structure specifies the
     *                     primary key of the item to be checked, the name of the table where it resides, a
     *                     condition expression that must be satisfied for the transaction to succeed, and
     *                     a field indicating whether to retrieve the item's attributes if the condition is
     *                     not met.</p>
     *             </li>
     *          </ul>
     *
     *         <p>DynamoDB rejects the entire <code>TransactWriteItems</code> request if any of the
     *             following is true:</p>
     *         <ul>
     *             <li>
     *                 <p>A condition in one of the condition expressions is not met.</p>
     *             </li>
     *             <li>
     *                 <p>An ongoing operation is in the process of updating the same item.</p>
     *             </li>
     *             <li>
     *                 <p>There is insufficient provisioned capacity for the transaction to be
     *                     completed.</p>
     *             </li>
     *             <li>
     *                 <p>An item size becomes too large (bigger than 400 KB), a local secondary index
     *                     (LSI) becomes too large, or a similar validation error occurs because of changes
     *                     made by the transaction.</p>
     *             </li>
     *             <li>
     *                 <p>The aggregate size of the items in the transaction exceeds 4 MB.</p>
     *             </li>
     *             <li>
     *                 <p>There is a user error, such as an invalid data format.</p>
     *             </li>
     *          </ul>
     */
    transactWriteItems(args: TransactWriteItemsCommandInput, options?: __HttpHandlerOptions): Promise<TransactWriteItemsCommandOutput>;
    transactWriteItems(args: TransactWriteItemsCommandInput, cb: (err: any, data?: TransactWriteItemsCommandOutput) => void): void;
    transactWriteItems(args: TransactWriteItemsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TransactWriteItemsCommandOutput) => void): void;
    /**
     * <p>Removes the association of tags from an Amazon DynamoDB resource. You can call
     *                 <code>UntagResource</code> up to five 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>
     */
    untagResource(args: UntagResourceCommandInput, options?: __HttpHandlerOptions): Promise<UntagResourceCommandOutput>;
    untagResource(args: UntagResourceCommandInput, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
    untagResource(args: UntagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
    /**
     * <p>
     *             <code>UpdateContinuousBackups</code> enables or disables point in time recovery for
     *             the specified table. A successful <code>UpdateContinuousBackups</code> call returns the
     *             current <code>ContinuousBackupsDescription</code>. Continuous backups are
     *                 <code>ENABLED</code> on all tables at table creation. If point in time recovery is
     *             enabled, <code>PointInTimeRecoveryStatus</code> will be set to ENABLED.</p>
     *         <p> Once continuous backups and point in time recovery are enabled, you can restore to
     *             any point in time within <code>EarliestRestorableDateTime</code> and
     *                 <code>LatestRestorableDateTime</code>. </p>
     *         <p>
     *             <code>LatestRestorableDateTime</code> is typically 5 minutes before the current time.
     *             You can restore your table to any point in time during the last 35 days. </p>
     */
    updateContinuousBackups(args: UpdateContinuousBackupsCommandInput, options?: __HttpHandlerOptions): Promise<UpdateContinuousBackupsCommandOutput>;
    updateContinuousBackups(args: UpdateContinuousBackupsCommandInput, cb: (err: any, data?: UpdateContinuousBackupsCommandOutput) => void): void;
    updateContinuousBackups(args: UpdateContinuousBackupsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateContinuousBackupsCommandOutput) => void): void;
    /**
     * <p>Updates the status for contributor insights for a specific table or index. CloudWatch
     *             Contributor Insights for DynamoDB graphs display the partition key and (if applicable)
     *             sort key of frequently accessed items and frequently throttled items in plaintext. If
     *             you require the use of Amazon Web Services Key Management Service (KMS) to encrypt this
     *             table’s partition key and sort key data with an Amazon Web Services managed key or
     *             customer managed key, you should not enable CloudWatch Contributor Insights for DynamoDB
     *             for this table.</p>
     */
    updateContributorInsights(args: UpdateContributorInsightsCommandInput, options?: __HttpHandlerOptions): Promise<UpdateContributorInsightsCommandOutput>;
    updateContributorInsights(args: UpdateContributorInsightsCommandInput, cb: (err: any, data?: UpdateContributorInsightsCommandOutput) => void): void;
    updateContributorInsights(args: UpdateContributorInsightsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateContributorInsightsCommandOutput) => void): void;
    /**
     * <p>Adds or removes replicas in the specified global table. The global table must already
     *             exist to be able to use this operation. Any replica to be added must be empty, have the
     *             same name as the global table, have the same key schema, have DynamoDB Streams enabled,
     *             and have the same provisioned and maximum write capacity units.</p>
     *         <note>
     *             <p>Although you can use <code>UpdateGlobalTable</code> to add replicas and remove
     *                 replicas in a single request, for simplicity we recommend that you issue separate
     *                 requests for adding or removing replicas.</p>
     *         </note>
     *         <p> If global secondary indexes are specified, then the following conditions must also be
     *             met: </p>
     *         <ul>
     *             <li>
     *                 <p> The global secondary indexes must have the same name. </p>
     *             </li>
     *             <li>
     *                 <p> The global secondary indexes must have the same hash key and sort key (if
     *                     present). </p>
     *             </li>
     *             <li>
     *                 <p> The global secondary indexes must have the same provisioned and maximum write
     *                     capacity units. </p>
     *             </li>
     *          </ul>
     */
    updateGlobalTable(args: UpdateGlobalTableCommandInput, options?: __HttpHandlerOptions): Promise<UpdateGlobalTableCommandOutput>;
    updateGlobalTable(args: UpdateGlobalTableCommandInput, cb: (err: any, data?: UpdateGlobalTableCommandOutput) => void): void;
    updateGlobalTable(args: UpdateGlobalTableCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateGlobalTableCommandOutput) => void): void;
    /**
     * <p>Updates settings for a global table.</p>
     */
    updateGlobalTableSettings(args: UpdateGlobalTableSettingsCommandInput, options?: __HttpHandlerOptions): Promise<UpdateGlobalTableSettingsCommandOutput>;
    updateGlobalTableSettings(args: UpdateGlobalTableSettingsCommandInput, cb: (err: any, data?: UpdateGlobalTableSettingsCommandOutput) => void): void;
    updateGlobalTableSettings(args: UpdateGlobalTableSettingsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateGlobalTableSettingsCommandOutput) => void): void;
    /**
     * <p>Edits an existing item's attributes, or adds a new item to the table if it does not
     *             already exist. You can put, delete, or add attribute values. You can also perform a
     *             conditional update on an existing item (insert a new attribute name-value pair if it
     *             doesn't exist, or replace an existing name-value pair if it has certain expected
     *             attribute values).</p>
     *         <p>You can also return the item's attribute values in the same <code>UpdateItem</code>
     *             operation using the <code>ReturnValues</code> parameter.</p>
     */
    updateItem(args: UpdateItemCommandInput, options?: __HttpHandlerOptions): Promise<UpdateItemCommandOutput>;
    updateItem(args: UpdateItemCommandInput, cb: (err: any, data?: UpdateItemCommandOutput) => void): void;
    updateItem(args: UpdateItemCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateItemCommandOutput) => void): void;
    /**
     * <p>Modifies the provisioned throughput settings, global secondary indexes, or DynamoDB
     *             Streams settings for a given table.</p>
     *         <p>You can only perform one of the following operations at once:</p>
     *         <ul>
     *             <li>
     *                 <p>Modify the provisioned throughput settings of the table.</p>
     *             </li>
     *             <li>
     *                 <p>Remove a global secondary index from the table.</p>
     *             </li>
     *             <li>
     *                 <p>Create a new global secondary index on the table. After the index begins
     *                     backfilling, you can use <code>UpdateTable</code> to perform other
     *                     operations.</p>
     *             </li>
     *          </ul>
     *         <p>
     *             <code>UpdateTable</code> is an asynchronous operation; while it is executing, the table
     *             status changes from <code>ACTIVE</code> to <code>UPDATING</code>. While it is
     *                 <code>UPDATING</code>, you cannot issue another <code>UpdateTable</code> request.
     *             When the table returns to the <code>ACTIVE</code> state, the <code>UpdateTable</code>
     *             operation is complete.</p>
     */
    updateTable(args: UpdateTableCommandInput, options?: __HttpHandlerOptions): Promise<UpdateTableCommandOutput>;
    updateTable(args: UpdateTableCommandInput, cb: (err: any, data?: UpdateTableCommandOutput) => void): void;
    updateTable(args: UpdateTableCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateTableCommandOutput) => void): void;
    /**
     * <p>Updates auto scaling settings on your global tables 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>
     */
    updateTableReplicaAutoScaling(args: UpdateTableReplicaAutoScalingCommandInput, options?: __HttpHandlerOptions): Promise<UpdateTableReplicaAutoScalingCommandOutput>;
    updateTableReplicaAutoScaling(args: UpdateTableReplicaAutoScalingCommandInput, cb: (err: any, data?: UpdateTableReplicaAutoScalingCommandOutput) => void): void;
    updateTableReplicaAutoScaling(args: UpdateTableReplicaAutoScalingCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateTableReplicaAutoScalingCommandOutput) => void): void;
    /**
     * <p>The <code>UpdateTimeToLive</code> method enables or disables Time to Live (TTL) for
     *             the specified table. A successful <code>UpdateTimeToLive</code> call returns the current
     *                 <code>TimeToLiveSpecification</code>. It can take up to one hour for the change to
     *             fully process. Any additional <code>UpdateTimeToLive</code> calls for the same table
     *             during this one hour duration result in a <code>ValidationException</code>. </p>
     *         <p>TTL compares the current time in epoch time format to the time stored in the TTL
     *             attribute of an item. If the epoch time value stored in the attribute is less than the
     *             current time, the item is marked as expired and subsequently deleted.</p>
     *         <note>
     *             <p> The epoch time format is the number of seconds elapsed since 12:00:00 AM January
     *                 1, 1970 UTC. </p>
     *         </note>
     *         <p>DynamoDB deletes expired items on a best-effort basis to ensure availability of
     *             throughput for other data operations. </p>
     *         <important>
     *             <p>DynamoDB typically deletes expired items within two days of expiration. The exact
     *                 duration within which an item gets deleted after expiration is specific to the
     *                 nature of the workload. Items that have expired and not been deleted will still show
     *                 up in reads, queries, and scans.</p>
     *         </important>
     *         <p>As items are deleted, they are removed from any local secondary index and global
     *             secondary index immediately in the same eventually consistent way as a standard delete
     *             operation.</p>
     *         <p>For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/TTL.html">Time To Live</a> in the
     *             Amazon DynamoDB Developer Guide. </p>
     */
    updateTimeToLive(args: UpdateTimeToLiveCommandInput, options?: __HttpHandlerOptions): Promise<UpdateTimeToLiveCommandOutput>;
    updateTimeToLive(args: UpdateTimeToLiveCommandInput, cb: (err: any, data?: UpdateTimeToLiveCommandOutput) => void): void;
    updateTimeToLive(args: UpdateTimeToLiveCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateTimeToLiveCommandOutput) => void): void;
}
