@aws-sdk/client-dynamodb 3.282.0 → 3.284.0

package/dist-types/DynamoDBClient.d.ts

@@ -184,20 +184,17 @@ export interface DynamoDBClientResolvedConfig extends DynamoDBClientResolvedConf
 }
 /**
  * <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

package/dist-types/commands/BatchExecuteStatementCommand.d.ts

@@ -18,15 +18,15 @@ export interface BatchExecuteStatementCommandOutput extends BatchExecuteStatemen
  *             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>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

package/dist-types/commands/BatchGetItemCommand.d.ts

@@ -16,30 +16,30 @@ export interface BatchGetItemCommandOutput extends BatchGetItemOutput, __Metadat
 /**
  * <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
@@ -48,16 +48,16 @@ export interface BatchGetItemCommandOutput extends BatchGetItemOutput, __Metadat
  *                 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>

package/dist-types/commands/BatchWriteItemCommand.d.ts

@@ -20,14 +20,14 @@ export interface BatchWriteItemCommandOutput extends BatchWriteItemOutput, __Met
  *             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
@@ -36,11 +36,11 @@ export interface BatchWriteItemCommandOutput extends BatchWriteItemOutput, __Met
  *                 <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
@@ -49,52 +49,51 @@ export interface BatchWriteItemCommandOutput extends BatchWriteItemOutput, __Met
  *                 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>
  * @example

package/dist-types/commands/CreateBackupCommand.d.ts

@@ -15,33 +15,33 @@ export interface CreateBackupCommandOutput extends CreateBackupOutput, __Metadat
 }
 /**
  * <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>
  * @example

package/dist-types/commands/CreateGlobalTableCommand.d.ts

@@ -17,52 +17,58 @@ export interface CreateGlobalTableCommandOutput extends CreateGlobalTableOutput,
  * <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>
@@ -70,7 +76,7 @@ export interface CreateGlobalTableCommandOutput extends CreateGlobalTableOutput,
  *                 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>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

package/dist-types/commands/CreateTableCommand.d.ts

@@ -16,17 +16,17 @@ export interface CreateTableCommandOutput extends CreateTableOutput, __MetadataB
 /**
  * <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>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

package/dist-types/commands/DeleteBackupCommand.d.ts

@@ -15,7 +15,7 @@ export interface DeleteBackupCommandOutput extends DeleteBackupOutput, __Metadat
 }
 /**
  * <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>
  * @example
  * Use a bare-bones client and the command you need to make an API call.

package/dist-types/commands/DeleteItemCommand.d.ts

@@ -17,12 +17,12 @@ export interface DeleteItemCommandOutput extends DeleteItemOutput, __MetadataBea
  * <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>
  * @example

package/dist-types/commands/DeleteTableCommand.d.ts

@@ -22,17 +22,21 @@ export interface DeleteTableCommandOutput extends DeleteTableOutput, __MetadataB
  *                 <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>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

package/dist-types/commands/DescribeBackupCommand.d.ts

@@ -15,7 +15,7 @@ export interface DescribeBackupCommandOutput extends DescribeBackupOutput, __Met
 }
 /**
  * <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>
  * @example
  * Use a bare-bones client and the command you need to make an API call.

package/dist-types/commands/DescribeContinuousBackupsCommand.d.ts

@@ -18,13 +18,13 @@ export interface DescribeContinuousBackupsCommandOutput extends DescribeContinuo
  *             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>
  * @example
  * Use a bare-bones client and the command you need to make an API call.

package/dist-types/commands/DescribeContributorInsightsCommand.d.ts

@@ -14,7 +14,7 @@ export interface DescribeContributorInsightsCommandInput extends DescribeContrib
 export interface DescribeContributorInsightsCommandOutput extends DescribeContributorInsightsOutput, __MetadataBearer {
 }
 /**
- * <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>
  * @example
  * Use a bare-bones client and the command you need to make an API call.

package/dist-types/commands/DescribeEndpointsCommand.d.ts

@@ -14,7 +14,9 @@ export interface DescribeEndpointsCommandInput extends DescribeEndpointsRequest
 export interface DescribeEndpointsCommandOutput extends DescribeEndpointsResponse, __MetadataBearer {
 }
 /**
- * <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>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

package/dist-types/commands/DescribeGlobalTableCommand.d.ts

@@ -15,11 +15,18 @@ export interface DescribeGlobalTableCommandOutput extends DescribeGlobalTableOut
 }
 /**
  * <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>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

package/dist-types/commands/DescribeGlobalTableSettingsCommand.d.ts

@@ -15,10 +15,18 @@ export interface DescribeGlobalTableSettingsCommandOutput extends DescribeGlobal
 }
 /**
  * <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>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript