@aws-sdk/client-dynamodb 3.282.0 → 3.287.0

package/dist-types/DynamoDB.d.ts

@@ -55,20 +55,17 @@ import { UpdateTimeToLiveCommandInput, UpdateTimeToLiveCommandOutput } from "./c
 import { DynamoDBClient } from "./DynamoDBClient";
 /**
  * <fullname>Amazon DynamoDB</fullname>
- *
- *         <p>Amazon DynamoDB is a fully managed NoSQL database service that provides fast
+ *          <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
+ *          <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
+ *          <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
@@ -81,15 +78,15 @@ export declare class DynamoDB extends DynamoDBClient {
      *             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>
+     *          <note>
      *             <p>The entire batch must consist of either read statements or write statements, you
      *                 cannot mix both in one batch.</p>
-     *         </note>
-     *         <important>
+     *          </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>
+     *          </important>
      */
     batchExecuteStatement(args: BatchExecuteStatementCommandInput, options?: __HttpHandlerOptions): Promise<BatchExecuteStatementCommandOutput>;
     batchExecuteStatement(args: BatchExecuteStatementCommandInput, cb: (err: any, data?: BatchExecuteStatementCommandOutput) => void): void;
@@ -97,30 +94,30 @@ export declare class DynamoDB extends DynamoDBClient {
     /**
      * <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
+     *          <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>
+     *          <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
+     *          </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
+     *          <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>
+     *          <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
@@ -129,16 +126,16 @@ export declare class DynamoDB extends DynamoDBClient {
      *                 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
+     *          </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
+     *          <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
+     *          <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
+     *          <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>
@@ -153,14 +150,14 @@ export declare class DynamoDB extends DynamoDBClient {
      *             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>
+     *          <note>
      *             <p>
-     *                 <code>BatchWriteItem</code> cannot update items. If you perform a <code>BatchWriteItem</code>
+     *                <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
+     *          </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
@@ -169,11 +166,11 @@ export declare class DynamoDB extends DynamoDBClient {
      *                 <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
+     *          <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>
+     *          <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
@@ -182,52 +179,51 @@ export declare class DynamoDB extends DynamoDBClient {
      *                 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
+     *          </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
+     *          <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
+     *          <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
+     *          <p>If one or more of the following is true, DynamoDB rejects the entire batch write
      *             operation:</p>
-     *         <ul>
+     *          <ul>
      *             <li>
-     *                 <p>One or more tables specified in the <code>BatchWriteItem</code> request does
+     *                <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
+     *                <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
+     *                <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
+     *                <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>
+     *                <p>There are more than 25 requests in the batch.</p>
      *             </li>
      *             <li>
-     *                 <p>Any individual item in a batch exceeds 400 KB.</p>
+     *                <p>Any individual item in a batch exceeds 400 KB.</p>
      *             </li>
      *             <li>
-     *                 <p>The total request size exceeds 16 MB.</p>
+     *                <p>The total request size exceeds 16 MB.</p>
      *             </li>
      *          </ul>
      */
@@ -236,33 +232,33 @@ export declare class DynamoDB extends DynamoDBClient {
     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
+     *          <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
+     *          <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
+     *          <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
+     *          <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
+     *          <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>
+     *          <p> Along with data, the following are also included on the backups: </p>
+     *          <ul>
      *             <li>
-     *                 <p>Global secondary indexes (GSIs)</p>
+     *                <p>Global secondary indexes (GSIs)</p>
      *             </li>
      *             <li>
-     *                 <p>Local secondary indexes (LSIs)</p>
+     *                <p>Local secondary indexes (LSIs)</p>
      *             </li>
      *             <li>
-     *                 <p>Streams</p>
+     *                <p>Streams</p>
      *             </li>
      *             <li>
-     *                 <p>Provisioned read and write capacity</p>
+     *                <p>Provisioned read and write capacity</p>
      *             </li>
      *          </ul>
      */
@@ -273,52 +269,58 @@ export declare class DynamoDB extends DynamoDBClient {
      * <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>
+     *          <important>
      *             <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
+     *                 2017.11.29 (Legacy)</a> of global tables. We recommend using
+     *                 <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 2019.11.21 (Current)</a>
+     *                 when creating new global tables, as it provides greater flexibility, higher efficiency and consumes less write capacity than
+     *                 2017.11.29 (Legacy). To determine which version you are using, see
+     *                 <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.DetermineVersion.html">Determining the version</a>.
+     *                 To update existing global tables from version 2017.11.29 (Legacy) to version
+     *                 2019.11.21 (Current), see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/V2globaltables_upgrade.html">
+     *                     Updating global tables</a>.
+     *             </p>
+     *          </important>
+     *          <p>If you want to add a new replica table to a global table, each of the following
      *             conditions must be true:</p>
-     *         <ul>
+     *          <ul>
      *             <li>
-     *                 <p>The table must have the same primary key as all of the other replicas.</p>
+     *                <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>
+     *                <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
+     *                <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>
+     *                <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
+     *          <p> If global secondary indexes are specified, then the following conditions must also be
      *             met: </p>
-     *         <ul>
+     *          <ul>
      *             <li>
-     *                 <p> The global secondary indexes must have the same name. </p>
+     *                <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
+     *                <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
+     *          <p> If local secondary indexes are specified, then the following conditions must also be
      *             met: </p>
-     *         <ul>
+     *          <ul>
      *             <li>
-     *                 <p> The local secondary indexes must have the same name. </p>
+     *                <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
+     *                <p> The local secondary indexes must have the same hash key and sort key (if
      *                     present). </p>
      *             </li>
      *          </ul>
-     *
-     *         <important>
+     *          <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>
@@ -326,7 +328,7 @@ export declare class DynamoDB extends DynamoDBClient {
      *                 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>
+     *          </important>
      */
     createGlobalTable(args: CreateGlobalTableCommandInput, options?: __HttpHandlerOptions): Promise<CreateGlobalTableCommandOutput>;
     createGlobalTable(args: CreateGlobalTableCommandInput, cb: (err: any, data?: CreateGlobalTableCommandOutput) => void): void;
@@ -334,24 +336,24 @@ export declare class DynamoDB extends DynamoDBClient {
     /**
      * <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>
+     *          <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
+     *          <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>
+     *          <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
+     *          <p>You can call <code>DeleteBackup</code> at a maximum rate of 10 times per
      *             second.</p>
      */
     deleteBackup(args: DeleteBackupCommandInput, options?: __HttpHandlerOptions): Promise<DeleteBackupCommandOutput>;
@@ -361,12 +363,12 @@ export declare class DynamoDB extends DynamoDBClient {
      * <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
+     *          <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;
+     *          <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.
+     *          <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>
      */
@@ -382,24 +384,28 @@ export declare class DynamoDB extends DynamoDBClient {
      *                 <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>
+     *          <important>
+     *             <p>This operation only applies to <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 2019.11.21 (Current)</a>
+     *                 of global tables.
+     *             </p>
+     *          </important>
+     *          <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
+     *          </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>
+     *          <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
+     *          <p>You can call <code>DescribeBackup</code> at a maximum rate of 10 times per
      *             second.</p>
      */
     describeBackup(args: DescribeBackupCommandInput, options?: __HttpHandlerOptions): Promise<DescribeBackupCommandOutput>;
@@ -410,27 +416,29 @@ export declare class DynamoDB extends DynamoDBClient {
      *             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
+     *          <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>
+     *          <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
+     *          <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
+     * <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>
+     * <p>Returns the regional endpoint information. This action must be included in your VPC
+     *             endpoint policies, or access to the DescribeEndpoints API will be denied. For more information
+     *             on policy permissions, please see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/inter-network-traffic-privacy.html#inter-network-traffic-DescribeEndpoints">Internetwork traffic privacy</a>.</p>
      */
     describeEndpoints(args: DescribeEndpointsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeEndpointsCommandOutput>;
     describeEndpoints(args: DescribeEndpointsCommandInput, cb: (err: any, data?: DescribeEndpointsCommandOutput) => void): void;
@@ -443,21 +451,36 @@ export declare class DynamoDB extends DynamoDBClient {
     describeExport(args: DescribeExportCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeExportCommandOutput) => void): void;
     /**
      * <p>Returns information about the specified global table.</p>
-     *         <note>
+     *          <important>
      *             <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>
+     *                 2017.11.29 (Legacy)</a> of global tables. We recommend using
+     *                 <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 2019.11.21 (Current)</a>
+     *                 when creating new global tables, as it provides greater flexibility, higher efficiency and consumes less write capacity than
+     *                 2017.11.29 (Legacy). To determine which version you are using, see
+     *                 <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.DetermineVersion.html">Determining the version</a>.
+     *                 To update existing global tables from version 2017.11.29 (Legacy) to version
+     *                 2019.11.21 (Current), see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/V2globaltables_upgrade.html">
+     *                     Updating global tables</a>.
+     *             </p>
+     *          </important>
      */
     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>
+     *          <important>
      *             <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>
+     *                 2017.11.29 (Legacy)</a> of global tables. We recommend using
+     *                 <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 2019.11.21 (Current)</a>
+     *                 when creating new global tables, as it provides greater flexibility, higher efficiency and consumes less write capacity than
+     *                 2017.11.29 (Legacy). To determine which version you are using, see
+     *                 <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.DetermineVersion.html">Determining the version</a>.
+     *                 To update existing global tables from version 2017.11.29 (Legacy) to version
+     *                 2019.11.21 (Current), see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/V2globaltables_upgrade.html">
+     *                     Updating global tables</a>.
+     *             </p>
+     *          </important>
      */
     describeGlobalTableSettings(args: DescribeGlobalTableSettingsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeGlobalTableSettingsCommandOutput>;
     describeGlobalTableSettings(args: DescribeGlobalTableSettingsCommandInput, cb: (err: any, data?: DescribeGlobalTableSettingsCommandOutput) => void): void;
@@ -478,77 +501,73 @@ export declare class DynamoDB extends DynamoDBClient {
      * <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
+     *          <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
+     *          <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
+     *          <p>For example, you could use one of the Amazon Web Services SDKs to do the
      *             following:</p>
-     *
-     *         <ol>
+     *          <ol>
      *             <li>
-     *                 <p>Call <code>DescribeLimits</code> for a particular Region to obtain your
+     *                <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
+     *                <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
+     *                <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
+     *                <p>For each table name listed by <code>ListTables</code>, do the
      *                     following:</p>
-     *                 <ul>
+     *                <ul>
      *                   <li>
-     *                         <p>Call <code>DescribeTable</code> with the table name.</p>
-     *                     </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
+     *                      <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>
      *                   <li>
-     *                         <p>If the table has one or more global secondary indexes (GSIs), loop
+     *                      <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>
+     *                   </li>
      *                </ul>
      *             </li>
      *             <li>
-     *                 <p>Report the account quotas for that Region returned by
+     *                <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
+     *          <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
+     *          <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
+     *          <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>
+     *          <note>
      *             <p>
-     *                 <code>DescribeLimits</code> should only be called periodically. You can expect
+     *                <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>
+     *          </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;
@@ -556,24 +575,29 @@ export declare class DynamoDB extends DynamoDBClient {
     /**
      * <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>
+     *          <important>
+     *             <p>This operation only applies to <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 2019.11.21 (Current)</a>
+     *                 of global tables.
+     *             </p>
+     *          </important>
+     *          <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>
+     *          </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>
+     *          <important>
+     *             <p>This operation only applies to <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 2019.11.21 (Current)</a>
+     *             of global tables.</p>
+     *          </important>
      */
     describeTableReplicaAutoScaling(args: DescribeTableReplicaAutoScalingCommandInput, options?: __HttpHandlerOptions): Promise<DescribeTableReplicaAutoScalingCommandOutput>;
     describeTableReplicaAutoScaling(args: DescribeTableReplicaAutoScalingCommandInput, cb: (err: any, data?: DescribeTableReplicaAutoScalingCommandOutput) => void): void;
@@ -603,16 +627,17 @@ export declare class DynamoDB extends DynamoDBClient {
     /**
      * <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
+     *          <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
+     *          <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>
+     *             result set. If <code>NextToken</code> is present, you need to paginate the result set and include
+     *             <code>NextToken</code>.</p>
      */
     executeStatement(args: ExecuteStatementCommandInput, options?: __HttpHandlerOptions): Promise<ExecuteStatementCommandOutput>;
     executeStatement(args: ExecuteStatementCommandInput, cb: (err: any, data?: ExecuteStatementCommandOutput) => void): void;
@@ -620,12 +645,12 @@ export declare class DynamoDB extends DynamoDBClient {
     /**
      * <p>This operation allows you to perform transactional reads or writes on data stored in
      *             DynamoDB, using PartiQL.</p>
-     *         <note>
+     *          <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>
+     *          </note>
      */
     executeTransaction(args: ExecuteTransactionCommandInput, options?: __HttpHandlerOptions): Promise<ExecuteTransactionCommandOutput>;
     executeTransaction(args: ExecuteTransactionCommandInput, cb: (err: any, data?: ExecuteTransactionCommandOutput) => void): void;
@@ -642,7 +667,7 @@ export declare class DynamoDB extends DynamoDBClient {
      * <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>
+     *          <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
@@ -662,9 +687,9 @@ export declare class DynamoDB extends DynamoDBClient {
      *             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
+     *          <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>
+     *          <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;
@@ -684,10 +709,18 @@ export declare class DynamoDB extends DynamoDBClient {
     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>
+     *          <important>
      *             <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>
+     *                 2017.11.29 (Legacy)</a> of global tables. We recommend using
+     *                 <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 2019.11.21 (Current)</a>
+     *                 when creating new global tables, as it provides greater flexibility, higher efficiency and consumes less write capacity than
+     *                 2017.11.29 (Legacy). To determine which version you are using, see
+     *                 <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.DetermineVersion.html">Determining the version</a>.
+     *                 To update existing global tables from version 2017.11.29 (Legacy) to version
+     *                 2019.11.21 (Current), see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/V2globaltables_upgrade.html">
+     *                     Updating global tables</a>.
+     *             </p>
+     *          </important>
      */
     listGlobalTables(args: ListGlobalTablesCommandInput, options?: __HttpHandlerOptions): Promise<ListGlobalTablesCommandOutput>;
     listGlobalTables(args: ListGlobalTablesCommandInput, cb: (err: any, data?: ListGlobalTablesCommandOutput) => void): void;
@@ -709,7 +742,7 @@ export declare class DynamoDB extends DynamoDBClient {
     /**
      * <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>
+     *          <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>;
@@ -722,22 +755,21 @@ export declare class DynamoDB extends DynamoDBClient {
      *             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>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
+     *          <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
+     *          <p>Invalid Requests with empty values will be rejected with a
      *                 <code>ValidationException</code> exception.</p>
-     *         <note>
+     *          <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
+     *          </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>;
@@ -748,8 +780,7 @@ export declare class DynamoDB extends DynamoDBClient {
      *             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
+     *          <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
@@ -758,39 +789,39 @@ export declare class DynamoDB extends DynamoDBClient {
      *                 <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
+     *          <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>
+     *          <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>
+     *          </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
+     *          <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>
+     *          <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>
+     *          <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
+     *          </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
@@ -803,27 +834,27 @@ export declare class DynamoDB extends DynamoDBClient {
     /**
      * <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
+     *          <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>
+     *          <p>You must manually set up the following on the restored table:</p>
+     *          <ul>
      *             <li>
-     *                 <p>Auto scaling policies</p>
+     *                <p>Auto scaling policies</p>
      *             </li>
      *             <li>
-     *                 <p>IAM policies</p>
+     *                <p>IAM policies</p>
      *             </li>
      *             <li>
-     *                 <p>Amazon CloudWatch metrics and alarms</p>
+     *                <p>Amazon CloudWatch metrics and alarms</p>
      *             </li>
      *             <li>
-     *                 <p>Tags</p>
+     *                <p>Tags</p>
      *             </li>
      *             <li>
-     *                 <p>Stream settings</p>
+     *                <p>Stream settings</p>
      *             </li>
      *             <li>
-     *                 <p>Time to Live (TTL) settings</p>
+     *                <p>Time to Live (TTL) settings</p>
      *             </li>
      *          </ul>
      */
@@ -835,51 +866,50 @@ export declare class DynamoDB extends DynamoDBClient {
      *                 <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
+     *          <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
+     *          <p> Along with data, the following are also included on the new restored table using
      *             point in time recovery: </p>
-     *         <ul>
+     *          <ul>
      *             <li>
-     *                 <p>Global secondary indexes (GSIs)</p>
+     *                <p>Global secondary indexes (GSIs)</p>
      *             </li>
      *             <li>
-     *                 <p>Local secondary indexes (LSIs)</p>
+     *                <p>Local secondary indexes (LSIs)</p>
      *             </li>
      *             <li>
-     *                 <p>Provisioned read and write capacity</p>
+     *                <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
+     *                <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>
+     *                </important>
      *             </li>
      *          </ul>
-     *
-     *         <p>You must manually set up the following on the restored table:</p>
-     *         <ul>
+     *          <p>You must manually set up the following on the restored table:</p>
+     *          <ul>
      *             <li>
-     *                 <p>Auto scaling policies</p>
+     *                <p>Auto scaling policies</p>
      *             </li>
      *             <li>
-     *                 <p>IAM policies</p>
+     *                <p>IAM policies</p>
      *             </li>
      *             <li>
-     *                 <p>Amazon CloudWatch metrics and alarms</p>
+     *                <p>Amazon CloudWatch metrics and alarms</p>
      *             </li>
      *             <li>
-     *                 <p>Tags</p>
+     *                <p>Tags</p>
      *             </li>
      *             <li>
-     *                 <p>Stream settings</p>
+     *                <p>Stream settings</p>
      *             </li>
      *             <li>
-     *                 <p>Time to Live (TTL) settings</p>
+     *                <p>Time to Live (TTL) settings</p>
      *             </li>
      *             <li>
-     *                 <p>Point in time recovery settings</p>
+     *                <p>Point in time recovery settings</p>
      *             </li>
      *          </ul>
      */
@@ -890,24 +920,24 @@ export declare class DynamoDB extends DynamoDBClient {
      * <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,
+     *          <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
+     *          <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>
+     *          <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>
+     *          <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
@@ -922,7 +952,7 @@ export declare class DynamoDB extends DynamoDBClient {
      *             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>
+     *          <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>;
@@ -938,22 +968,22 @@ export declare class DynamoDB extends DynamoDBClient {
      *             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
+     *          <p>DynamoDB rejects the entire <code>TransactGetItems</code> request if any of
      *             the following is true:</p>
-     *         <ul>
+     *          <ul>
      *             <li>
-     *                 <p>A conflicting operation is in the process of updating an item to be
+     *                <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
+     *                <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>
+     *                <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>
+     *                <p>The aggregate size of the items in the transaction exceeded 4 MB.</p>
      *             </li>
      *          </ul>
      */
@@ -968,13 +998,11 @@ export declare class DynamoDB extends DynamoDBClient {
      *             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
+     *          <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>
+     *          <ul>
      *             <li>
-     *                 <p>
+     *                <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
@@ -983,7 +1011,7 @@ export declare class DynamoDB extends DynamoDBClient {
      *                     the condition is not met.</p>
      *             </li>
      *             <li>
-     *                 <p>
+     *                <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
@@ -993,7 +1021,7 @@ export declare class DynamoDB extends DynamoDBClient {
      *                     met.</p>
      *             </li>
      *             <li>
-     *                 <p>
+     *                <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
@@ -1002,7 +1030,7 @@ export declare class DynamoDB extends DynamoDBClient {
      *                     not met.</p>
      *             </li>
      *             <li>
-     *                 <p>
+     *                <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
@@ -1011,30 +1039,29 @@ export declare class DynamoDB extends DynamoDBClient {
      *                     not met.</p>
      *             </li>
      *          </ul>
-     *
-     *         <p>DynamoDB rejects the entire <code>TransactWriteItems</code> request if any of the
+     *          <p>DynamoDB rejects the entire <code>TransactWriteItems</code> request if any of the
      *             following is true:</p>
-     *         <ul>
+     *          <ul>
      *             <li>
-     *                 <p>A condition in one of the condition expressions is not met.</p>
+     *                <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>
+     *                <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
+     *                <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
+     *                <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>
+     *                <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>
+     *                <p>There is a user error, such as an invalid data format.</p>
      *             </li>
      *          </ul>
      */
@@ -1044,7 +1071,7 @@ export declare class DynamoDB extends DynamoDBClient {
     /**
      * <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>
+     *          <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>;
@@ -1057,10 +1084,10 @@ export declare class DynamoDB extends DynamoDBClient {
      *             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
+     *          <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>
+     *          <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>
      */
@@ -1084,23 +1111,42 @@ export declare class DynamoDB extends DynamoDBClient {
      *             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
+     *          <important>
+     *             <p>This operation only applies to <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html">Version
+     *                 2017.11.29 (Legacy)</a> of global tables. We recommend using
+     *                 <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 2019.11.21 (Current)</a>
+     *                 when creating new global tables, as it provides greater flexibility, higher efficiency and consumes less write capacity than
+     *                 2017.11.29 (Legacy). To determine which version you are using, see
+     *                 <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.DetermineVersion.html">Determining the version</a>.
+     *                 To update existing global tables from version 2017.11.29 (Legacy) to version
+     *                 2019.11.21 (Current), see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/V2globaltables_upgrade.html">
+     *                     Updating global tables</a>.
+     *             </p>
+     *          </important>
+     *          <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>
+     *             <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
+     *                 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>
+     *          <ul>
      *             <li>
-     *                 <p> The global secondary indexes must have the same name. </p>
+     *                <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
+     *                <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
+     *                <p> The global secondary indexes must have the same provisioned and maximum write
      *                     capacity units. </p>
      *             </li>
      *          </ul>
@@ -1110,6 +1156,18 @@ export declare class DynamoDB extends DynamoDBClient {
     updateGlobalTable(args: UpdateGlobalTableCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateGlobalTableCommandOutput) => void): void;
     /**
      * <p>Updates settings for a global table.</p>
+     *          <important>
+     *             <p>This operation only applies to <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html">Version
+     *                 2017.11.29 (Legacy)</a> of global tables. We recommend using
+     *                 <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 2019.11.21 (Current)</a>
+     *                 when creating new global tables, as it provides greater flexibility, higher efficiency and consumes less write capacity than
+     *                 2017.11.29 (Legacy). To determine which version you are using, see
+     *                 <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.DetermineVersion.html">Determining the version</a>.
+     *                 To update existing global tables from version 2017.11.29 (Legacy) to version
+     *                 2019.11.21 (Current), see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/V2globaltables_upgrade.html">
+     *                     Updating global tables</a>.
+     *             </p>
+     *          </important>
      */
     updateGlobalTableSettings(args: UpdateGlobalTableSettingsCommandInput, options?: __HttpHandlerOptions): Promise<UpdateGlobalTableSettingsCommandOutput>;
     updateGlobalTableSettings(args: UpdateGlobalTableSettingsCommandInput, cb: (err: any, data?: UpdateGlobalTableSettingsCommandOutput) => void): void;
@@ -1120,7 +1178,7 @@ export declare class DynamoDB extends DynamoDBClient {
      *             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>
+     *          <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>;
@@ -1129,21 +1187,26 @@ export declare class DynamoDB extends DynamoDBClient {
     /**
      * <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>
+     *          <important>
+     *             <p>This operation only applies to <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 2019.11.21 (Current)</a>
+     *                 of global tables.
+     *             </p>
+     *          </important>
+     *          <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>
+     *                <p>Modify the provisioned throughput settings of the table.</p>
      *             </li>
      *             <li>
-     *                 <p>Remove a global secondary index from the table.</p>
+     *                <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
+     *                <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>
+     *          <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.
@@ -1155,10 +1218,11 @@ export declare class DynamoDB extends DynamoDBClient {
     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>
+     *          <important>
+     *             <p>This operation only applies to <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 2019.11.21 (Current)</a>
+     *                 of global tables.
+     *             </p>
+     *          </important>
      */
     updateTableReplicaAutoScaling(args: UpdateTableReplicaAutoScalingCommandInput, options?: __HttpHandlerOptions): Promise<UpdateTableReplicaAutoScalingCommandOutput>;
     updateTableReplicaAutoScaling(args: UpdateTableReplicaAutoScalingCommandInput, cb: (err: any, data?: UpdateTableReplicaAutoScalingCommandOutput) => void): void;
@@ -1169,25 +1233,25 @@ export declare class DynamoDB extends DynamoDBClient {
      *                 <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
+     *          <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>
+     *          <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
+     *          </note>
+     *          <p>DynamoDB deletes expired items on a best-effort basis to ensure availability of
      *             throughput for other data operations. </p>
-     *         <important>
+     *          <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
+     *          </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
+     *          <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>;