@aws-sdk/client-kinesis 3.231.0 → 3.232.0

package/dist-types/KinesisClient.d.ts

@@ -158,7 +158,7 @@ export interface KinesisClientResolvedConfig extends KinesisClientResolvedConfig
 }
 /**
  * <fullname>Amazon Kinesis Data Streams Service API Reference</fullname>
- *         <p>Amazon Kinesis Data Streams is a managed service that scales elastically for real-time
+ *          <p>Amazon Kinesis Data Streams is a managed service that scales elastically for real-time
  *             processing of streaming big data.</p>
  */
 export declare class KinesisClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, KinesisClientResolvedConfig> {

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

@@ -10,9 +10,13 @@ export interface AddTagsToStreamCommandOutput extends __MetadataBearer {
 /**
  * <p>Adds or updates tags for the specified Kinesis data stream. You can assign up to 50
  *             tags to a data stream.</p>
- *         <p>If tags have already been assigned to the stream, <code>AddTagsToStream</code>
+ *          <note>
+ *             <p>When invoking this API, it is recommended you use the <code>StreamARN</code> input
+ *                 parameter rather than the <code>StreamName</code> input parameter.</p>
+ *          </note>
+ *          <p>If tags have already been assigned to the stream, <code>AddTagsToStream</code>
  *             overwrites any existing tags that correspond to the specified tag keys.</p>
- *         <p>
+ *          <p>
  *             <a>AddTagsToStream</a> has a limit of five transactions per second per
  *             account.</p>
  * @example

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

@@ -12,41 +12,44 @@ export interface CreateStreamCommandOutput extends __MetadataBearer {
  *             continuously emitted from different data sources or <i>producers</i>.
  *             Scale-out within a stream is explicitly supported by means of shards, which are uniquely
  *             identified groups of data records in a stream.</p>
- *         <p>You specify and control the number of shards that a stream is composed of. Each shard
- *             can support reads up to five transactions per second, up to a maximum data read total of
- *             2 MiB per second. Each shard can support writes up to 1,000 records per second, up to a
- *             maximum data write total of 1 MiB per second. If the amount of data input increases or
- *             decreases, you can add or remove shards.</p>
- *         <p>The stream name identifies the stream. The name is scoped to the Amazon Web Services
+ *          <p>You can create your data stream using either on-demand or provisioned capacity mode.
+ *             Data streams with an on-demand mode require no capacity planning and automatically scale
+ *             to handle gigabytes of write and read throughput per minute. With the on-demand mode,
+ *             Kinesis Data Streams automatically manages the shards in order to provide the necessary
+ *             throughput. For the data streams with a provisioned mode, you must specify the number of
+ *             shards for the data stream. Each shard can support reads up to five transactions per
+ *             second, up to a maximum data read total of 2 MiB per second. Each shard can support
+ *             writes up to 1,000 records per second, up to a maximum data write total of 1 MiB per
+ *             second. If the amount of data input increases or decreases, you can add or remove
+ *             shards.</p>
+ *          <p>The stream name identifies the stream. The name is scoped to the Amazon Web Services
  *             account used by the application. It is also scoped by Amazon Web Services Region. That
  *             is, two streams in two different accounts can have the same name, and two streams in the
  *             same account, but in two different Regions, can have the same name.</p>
- *         <p>
+ *          <p>
  *             <code>CreateStream</code> is an asynchronous operation. Upon receiving a
  *                 <code>CreateStream</code> request, Kinesis Data Streams immediately returns and sets
  *             the stream status to <code>CREATING</code>. After the stream is created, Kinesis Data
  *             Streams sets the stream status to <code>ACTIVE</code>. You should perform read and write
  *             operations only on an <code>ACTIVE</code> stream. </p>
- *         <p>You receive a <code>LimitExceededException</code> when making a
+ *          <p>You receive a <code>LimitExceededException</code> when making a
  *                 <code>CreateStream</code> request when you try to do one of the following:</p>
- *         <ul>
+ *          <ul>
  *             <li>
- *
- *                 <p>Have more than five streams in the <code>CREATING</code> state at any point in
+ *                <p>Have more than five streams in the <code>CREATING</code> state at any point in
  *                     time.</p>
  *             </li>
  *             <li>
- *
- *                 <p>Create more shards than are authorized for your account.</p>
+ *                <p>Create more shards than are authorized for your account.</p>
  *             </li>
  *          </ul>
- *         <p>For the default shard limit for an Amazon Web Services account, see <a href="https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html">Amazon
+ *          <p>For the default shard limit for an Amazon Web Services account, see <a href="https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html">Amazon
  *                 Kinesis Data Streams Limits</a> in the <i>Amazon Kinesis Data Streams
  *                 Developer Guide</i>. To increase this limit, <a href="https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html">contact Amazon Web Services
  *                 Support</a>.</p>
- *         <p>You can use <a>DescribeStreamSummary</a> to check the stream status, which
+ *          <p>You can use <a>DescribeStreamSummary</a> to check the stream status, which
  *             is returned in <code>StreamStatus</code>.</p>
- *         <p>
+ *          <p>
  *             <a>CreateStream</a> has a limit of five transactions per second per
  *             account.</p>
  * @example

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

@@ -11,7 +11,11 @@ export interface DecreaseStreamRetentionPeriodCommandOutput extends __MetadataBe
  * <p>Decreases the Kinesis data stream's retention period, which is the length of time data
  *             records are accessible after they are added to the stream. The minimum value of a
  *             stream's retention period is 24 hours.</p>
- *         <p>This operation may result in lost data. For example, if the stream's retention period
+ *          <note>
+ *             <p>When invoking this API, it is recommended you use the <code>StreamARN</code> input
+ *                 parameter rather than the <code>StreamName</code> input parameter.</p>
+ *          </note>
+ *          <p>This operation may result in lost data. For example, if the stream's retention period
  *             is 48 hours and is decreased to 24 hours, any data already in the stream that is older
  *             than 24 hours is inaccessible.</p>
  * @example

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

@@ -12,20 +12,23 @@ export interface DeleteStreamCommandOutput extends __MetadataBearer {
  *             applications that are operating on the stream before you delete the stream. If an
  *             application attempts to operate on a deleted stream, it receives the exception
  *                 <code>ResourceNotFoundException</code>.</p>
- *         <p>If the stream is in the <code>ACTIVE</code> state, you can delete it. After a
+ *          <note>
+ *             <p>When invoking this API, it is recommended you use the <code>StreamARN</code> input
+ *                 parameter rather than the <code>StreamName</code> input parameter.</p>
+ *          </note>
+ *          <p>If the stream is in the <code>ACTIVE</code> state, you can delete it. After a
  *                 <code>DeleteStream</code> request, the specified stream is in the
  *                 <code>DELETING</code> state until Kinesis Data Streams completes the
  *             deletion.</p>
- *         <p>
+ *          <p>
  *             <b>Note:</b> Kinesis Data Streams might continue to accept
  *             data read and write operations, such as <a>PutRecord</a>, <a>PutRecords</a>, and <a>GetRecords</a>, on a stream in the
  *                 <code>DELETING</code> state until the stream deletion is complete.</p>
- *         <p>When you delete a stream, any shards in that stream are also deleted, and any tags are
+ *          <p>When you delete a stream, any shards in that stream are also deleted, and any tags are
  *             dissociated from the stream.</p>
- *         <p>You can use the <a>DescribeStreamSummary</a> operation to check the state
+ *          <p>You can use the <a>DescribeStreamSummary</a> operation to check the state
  *             of the stream, which is returned in <code>StreamStatus</code>.</p>
- *
- *         <p>
+ *          <p>
  *             <a>DeleteStream</a> has a limit of five transactions per second per
  *             account.</p>
  * @example

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

@@ -15,7 +15,7 @@ export interface DeregisterStreamConsumerCommandOutput extends __MetadataBearer
  *                 <a>ListStreamConsumers</a> operation to get a list of the descriptions of
  *             all the consumers that are currently registered with a given data stream. The
  *             description of a consumer contains its name and ARN.</p>
- *         <p>This operation has a limit of five transactions per second per stream.</p>
+ *          <p>This operation has a limit of five transactions per second per stream.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

@@ -9,9 +9,9 @@ export interface DescribeLimitsCommandOutput extends DescribeLimitsOutput, __Met
 }
 /**
  * <p>Describes the shard limits and usage for the account.</p>
- *         <p>If you update your account limits, the old limits might be returned for a few
+ *          <p>If you update your account limits, the old limits might be returned for a few
  *             minutes.</p>
- *         <p>This operation has a limit of one transaction per second per account.</p>
+ *          <p>This operation has a limit of one transaction per second per account.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

@@ -9,26 +9,29 @@ export interface DescribeStreamCommandOutput extends DescribeStreamOutput, __Met
 }
 /**
  * <p>Describes the specified Kinesis data stream.</p>
- *         <note>
+ *          <note>
  *             <p>This API has been revised. It's highly recommended that you use the <a>DescribeStreamSummary</a> API to get a summarized description of the
  *                 specified Kinesis data stream and the <a>ListShards</a> API to list the
  *                 shards in a specified data stream and obtain information about each shard. </p>
- *         </note>
- *         <p>The information returned includes the stream name, Amazon Resource Name (ARN),
+ *          </note>
+ *          <note>
+ *             <p>When invoking this API, it is recommended you use the <code>StreamARN</code> input
+ *                 parameter rather than the <code>StreamName</code> input parameter.</p>
+ *          </note>
+ *          <p>The information returned includes the stream name, Amazon Resource Name (ARN),
  *             creation time, enhanced metric configuration, and shard map. The shard map is an array
  *             of shard objects. For each shard object, there is the hash key and sequence number
  *             ranges that the shard spans, and the IDs of any earlier shards that played in a role in
  *             creating the shard. Every record ingested in the stream is identified by a sequence
  *             number, which is assigned when the record is put into the stream.</p>
- *
- *         <p>You can limit the number of shards returned by each call. For more information, see
+ *          <p>You can limit the number of shards returned by each call. For more information, see
  *                 <a href="https://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-retrieve-shards.html">Retrieving
  *                 Shards from a Stream</a> in the <i>Amazon Kinesis Data Streams Developer
  *                 Guide</i>.</p>
- *         <p>There are no guarantees about the chronological order shards returned. To process
+ *          <p>There are no guarantees about the chronological order shards returned. To process
  *             shards in chronological order, use the ID of the parent shard to track the lineage to
  *             the oldest shard.</p>
- *         <p>This operation has a limit of 10 transactions per second per account.</p>
+ *          <p>This operation has a limit of 10 transactions per second per account.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

@@ -15,7 +15,7 @@ export interface DescribeStreamConsumerCommandOutput extends DescribeStreamConsu
  *             that you want to describe, you can use the <a>ListStreamConsumers</a>
  *             operation to get a list of the descriptions of all the consumers that are currently
  *             registered with a given data stream.</p>
- *         <p>This operation has a limit of 20 transactions per second per stream.</p>
+ *          <p>This operation has a limit of 20 transactions per second per stream.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

@@ -10,10 +10,14 @@ export interface DescribeStreamSummaryCommandOutput extends DescribeStreamSummar
 /**
  * <p>Provides a summarized description of the specified Kinesis data stream without the
  *             shard list.</p>
- *         <p>The information returned includes the stream name, Amazon Resource Name (ARN), status,
+ *          <note>
+ *             <p>When invoking this API, it is recommended you use the <code>StreamARN</code> input
+ *                 parameter rather than the <code>StreamName</code> input parameter.</p>
+ *          </note>
+ *          <p>The information returned includes the stream name, Amazon Resource Name (ARN), status,
  *             record retention period, approximate creation time, monitoring, encryption details, and
  *             open shard count. </p>
- *         <p>
+ *          <p>
  *             <a>DescribeStreamSummary</a> has a limit of 20 transactions per second per
  *             account.</p>
  * @example

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

@@ -9,6 +9,10 @@ export interface DisableEnhancedMonitoringCommandOutput extends EnhancedMonitori
 }
 /**
  * <p>Disables enhanced monitoring.</p>
+ *          <note>
+ *             <p>When invoking this API, it is recommended you use the <code>StreamARN</code> input
+ *                 parameter rather than the <code>StreamName</code> input parameter.</p>
+ *          </note>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

@@ -9,6 +9,10 @@ export interface EnableEnhancedMonitoringCommandOutput extends EnhancedMonitorin
 }
 /**
  * <p>Enables enhanced Kinesis data stream monitoring for shard-level metrics.</p>
+ *          <note>
+ *             <p>When invoking this API, it is recommended you use the <code>StreamARN</code> input
+ *                 parameter rather than the <code>StreamName</code> input parameter.</p>
+ *          </note>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

@@ -9,12 +9,16 @@ export interface GetRecordsCommandOutput extends GetRecordsOutput, __MetadataBea
 }
 /**
  * <p>Gets data records from a Kinesis data stream's shard.</p>
- *         <p>Specify a shard iterator using the <code>ShardIterator</code> parameter. The shard
+ *          <note>
+ *             <p>When invoking this API, it is recommended you use the <code>StreamARN</code> input
+ *                 parameter in addition to the <code>ShardIterator</code> parameter.</p>
+ *          </note>
+ *          <p>Specify a shard iterator using the <code>ShardIterator</code> parameter. The shard
  *             iterator specifies the position in the shard from which you want to start reading data
  *             records sequentially. If there are no records available in the portion of the shard that
  *             the iterator points to, <a>GetRecords</a> returns an empty list. It might
  *             take multiple calls to get to a portion of the shard that contains records.</p>
- *         <p>You can scale by provisioning multiple shards per stream while considering service
+ *          <p>You can scale by provisioning multiple shards per stream while considering service
  *             limits (for more information, see <a href="https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html">Amazon Kinesis Data Streams
  *                 Limits</a> in the <i>Amazon Kinesis Data Streams Developer
  *                 Guide</i>). Your application should have one thread per shard, each reading
@@ -26,14 +30,13 @@ export interface GetRecordsCommandOutput extends GetRecordsOutput, __MetadataBea
  *             You can terminate the loop when the shard is closed, or when the shard iterator reaches
  *             the record with the sequence number or other attribute that marks it as the last record
  *             to process.</p>
- *         <p>Each data record can be up to 1 MiB in size, and each shard can read up to 2 MiB per
+ *          <p>Each data record can be up to 1 MiB in size, and each shard can read up to 2 MiB per
  *             second. You can ensure that your calls don't exceed the maximum supported size or
  *             throughput by using the <code>Limit</code> parameter to specify the maximum number of
  *             records that <a>GetRecords</a> can return. Consider your average record size
  *             when determining this limit. The maximum number of records that can be returned per call
  *             is 10,000.</p>
- *
- *         <p>The size of the data returned by <a>GetRecords</a> varies depending on the
+ *          <p>The size of the data returned by <a>GetRecords</a> varies depending on the
  *             utilization of the shard. It is recommended that consumer applications retrieve records
  *             via the <code>GetRecords</code> command using the 5 TPS limit to remain caught up.
  *             Retrieving records less frequently can lead to consumer applications falling behind. The
@@ -45,26 +48,18 @@ export interface GetRecordsCommandOutput extends GetRecordsOutput, __MetadataBea
  *             doesn't return any data when it throws an exception. For this reason, we recommend that
  *             you wait 1 second between calls to <a>GetRecords</a>. However, it's possible
  *             that the application will get exceptions for longer than 1 second.</p>
- *
- *
- *
- *
- *
- *
- *
- *
- *         <p>To detect whether the application is falling behind in processing, you can use the
+ *          <p>To detect whether the application is falling behind in processing, you can use the
  *                 <code>MillisBehindLatest</code> response attribute. You can also monitor the stream
  *             using CloudWatch metrics and other mechanisms (see <a href="https://docs.aws.amazon.com/kinesis/latest/dev/monitoring.html">Monitoring</a> in the <i>Amazon
  *                 Kinesis Data Streams Developer Guide</i>).</p>
- *         <p>Each Amazon Kinesis record includes a value, <code>ApproximateArrivalTimestamp</code>,
+ *          <p>Each Amazon Kinesis record includes a value, <code>ApproximateArrivalTimestamp</code>,
  *             that is set when a stream successfully receives and stores a record. This is commonly
  *             referred to as a server-side time stamp, whereas a client-side time stamp is set when a
  *             data producer creates or sends the record to a stream (a data producer is any data
  *             source putting data records into a stream, for example with <a>PutRecords</a>). The time stamp has millisecond precision. There are no guarantees about the time
  *             stamp accuracy, or that the time stamp is always increasing. For example, records in a
  *             shard or across a stream might have time stamps that are out of order.</p>
- *         <p>This operation has a limit of five transactions per second per shard.</p>
+ *          <p>This operation has a limit of five transactions per second per shard.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

@@ -10,12 +10,16 @@ export interface GetShardIteratorCommandOutput extends GetShardIteratorOutput, _
 /**
  * <p>Gets an Amazon Kinesis shard iterator. A shard iterator expires 5 minutes after it is
  *             returned to the requester.</p>
- *         <p>A shard iterator specifies the shard position from which to start reading data records
+ *          <note>
+ *             <p>When invoking this API, it is recommended you use the <code>StreamARN</code> input
+ *                 parameter rather than the <code>StreamName</code> input parameter.</p>
+ *          </note>
+ *          <p>A shard iterator specifies the shard position from which to start reading data records
  *             sequentially. The position is specified using the sequence number of a data record in a
  *             shard. A sequence number is the identifier associated with every record ingested in the
  *             stream, and is assigned when a record is put into the stream. Each stream has one or
  *             more shards.</p>
- *         <p>You must specify the shard iterator type. For example, you can set the
+ *          <p>You must specify the shard iterator type. For example, you can set the
  *                 <code>ShardIteratorType</code> parameter to read exactly from the position denoted
  *             by a specific sequence number by using the <code>AT_SEQUENCE_NUMBER</code> shard
  *             iterator type. Alternatively, the parameter can read right after the sequence number by
@@ -27,19 +31,19 @@ export interface GetShardIteratorCommandOutput extends GetShardIteratorOutput, _
  *                 <code>ShardIterator</code> to point to the last untrimmed record in the shard in the
  *             system (the oldest data record in the shard), or <code>LATEST</code> so that you always
  *             read the most recent data in the shard. </p>
- *         <p>When you read repeatedly from a stream, use a <a>GetShardIterator</a>
+ *          <p>When you read repeatedly from a stream, use a <a>GetShardIterator</a>
  *             request to get the first shard iterator for use in your first <a>GetRecords</a> request and for subsequent reads use the shard iterator returned by the <a>GetRecords</a> request in <code>NextShardIterator</code>. A new shard
  *             iterator is returned by every <a>GetRecords</a> request in
  *                 <code>NextShardIterator</code>, which you use in the <code>ShardIterator</code>
  *             parameter of the next <a>GetRecords</a> request. </p>
- *         <p>If a <a>GetShardIterator</a> request is made too often, you receive a
+ *          <p>If a <a>GetShardIterator</a> request is made too often, you receive a
  *                 <code>ProvisionedThroughputExceededException</code>. For more information about
  *             throughput limits, see <a>GetRecords</a>, and <a href="https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html">Streams Limits</a> in the
  *                 <i>Amazon Kinesis Data Streams Developer Guide</i>.</p>
- *         <p>If the shard is closed, <a>GetShardIterator</a> returns a valid iterator
+ *          <p>If the shard is closed, <a>GetShardIterator</a> returns a valid iterator
  *             for the last sequence number of the shard. A shard can be closed as a result of using
  *                 <a>SplitShard</a> or <a>MergeShards</a>.</p>
- *         <p>
+ *          <p>
  *             <a>GetShardIterator</a> has a limit of five transactions per second per
  *             account per open shard.</p>
  * @example

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

@@ -11,7 +11,11 @@ export interface IncreaseStreamRetentionPeriodCommandOutput extends __MetadataBe
  * <p>Increases the Kinesis data stream's retention period, which is the length of time data
  *             records are accessible after they are added to the stream. The maximum value of a
  *             stream's retention period is 8760 hours (365 days).</p>
- *         <p>If you choose a longer stream retention period, this operation increases the time
+ *          <note>
+ *             <p>When invoking this API, it is recommended you use the <code>StreamARN</code> input
+ *                 parameter rather than the <code>StreamName</code> input parameter.</p>
+ *          </note>
+ *          <p>If you choose a longer stream retention period, this operation increases the time
  *             period during which records that have not yet expired are accessible. However, it does
  *             not make previous, expired data (older than the stream's previous retention period)
  *             accessible after the operation has been called. For example, if a stream's retention

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

@@ -10,15 +10,19 @@ export interface ListShardsCommandOutput extends ListShardsOutput, __MetadataBea
 /**
  * <p>Lists the shards in a stream and provides information about each shard. This operation
  *             has a limit of 1000 transactions per second per data stream.</p>
- *         <p>This action does not list expired shards. For information about expired shards, see
+ *          <note>
+ *             <p>When invoking this API, it is recommended you use the <code>StreamARN</code> input
+ *                 parameter rather than the <code>StreamName</code> input parameter.</p>
+ *          </note>
+ *          <p>This action does not list expired shards. For information about expired shards, see
  *                 <a href="https://docs.aws.amazon.com/streams/latest/dev/kinesis-using-sdk-java-after-resharding.html#kinesis-using-sdk-java-resharding-data-routing">Data Routing, Data Persistence, and Shard State after a Reshard</a>. </p>
- *         <important>
+ *          <important>
  *             <p>This API is a new operation that is used by the Amazon Kinesis Client Library
  *                 (KCL). If you have a fine-grained IAM policy that only allows specific operations,
  *                 you must update your policy to allow calls to this API. For more information, see
  *                     <a href="https://docs.aws.amazon.com/streams/latest/dev/controlling-access.html">Controlling Access to Amazon Kinesis Data Streams Resources Using
  *                 IAM</a>.</p>
- *         </important>
+ *          </important>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

@@ -10,7 +10,7 @@ export interface ListStreamConsumersCommandOutput extends ListStreamConsumersOut
 /**
  * <p>Lists the consumers registered to receive data from a stream using enhanced fan-out,
  *             and provides information about each consumer.</p>
- *         <p>This operation has a limit of 5 transactions per second per stream.</p>
+ *          <p>This operation has a limit of 5 transactions per second per stream.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

@@ -9,19 +9,19 @@ export interface ListStreamsCommandOutput extends ListStreamsOutput, __MetadataB
 }
 /**
  * <p>Lists your Kinesis data streams.</p>
- *         <p>The number of streams may be too large to return from a single call to
+ *          <p>The number of streams may be too large to return from a single call to
  *                 <code>ListStreams</code>. You can limit the number of returned streams using the
  *                 <code>Limit</code> parameter. If you do not specify a value for the
  *                 <code>Limit</code> parameter, Kinesis Data Streams uses the default limit, which is
  *             currently 100.</p>
- *         <p>You can detect if there are more streams available to list by using the
+ *          <p>You can detect if there are more streams available to list by using the
  *                 <code>HasMoreStreams</code> flag from the returned output. If there are more streams
  *             available, you can request more streams by using the name of the last stream returned by
  *             the <code>ListStreams</code> request in the <code>ExclusiveStartStreamName</code>
  *             parameter in a subsequent request to <code>ListStreams</code>. The group of stream names
  *             returned by the subsequent request is then added to the list. You can continue this
  *             process until all the stream names have been collected in the list. </p>
- *         <p>
+ *          <p>
  *             <a>ListStreams</a> has a limit of five transactions per second per
  *             account.</p>
  * @example

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

@@ -10,6 +10,10 @@ export interface ListTagsForStreamCommandOutput extends ListTagsForStreamOutput,
 /**
  * <p>Lists the tags for the specified Kinesis data stream. This operation has a limit of
  *             five transactions per second per account.</p>
+ *          <note>
+ *             <p>When invoking this API, it is recommended you use the <code>StreamARN</code> input
+ *                 parameter rather than the <code>StreamName</code> input parameter.</p>
+ *          </note>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

@@ -9,40 +9,45 @@ export interface MergeShardsCommandOutput extends __MetadataBearer {
 }
 /**
  * <p>Merges two adjacent shards in a Kinesis data stream and combines them into a single
- *             shard to reduce the stream's capacity to ingest and transport data. Two shards are
+ *             shard to reduce the stream's capacity to ingest and transport data. This API is only
+ *             supported for the data streams with the provisioned capacity mode. Two shards are
  *             considered adjacent if the union of the hash key ranges for the two shards form a
  *             contiguous set with no gaps. For example, if you have two shards, one with a hash key
  *             range of 276...381 and the other with a hash key range of 382...454, then you could
  *             merge these two shards into a single shard that would have a hash key range of
  *             276...454. After the merge, the single child shard receives data for all hash key values
  *             covered by the two parent shards.</p>
- *         <p>
+ *          <note>
+ *             <p>When invoking this API, it is recommended you use the <code>StreamARN</code> input
+ *                 parameter rather than the <code>StreamName</code> input parameter.</p>
+ *          </note>
+ *          <p>
  *             <code>MergeShards</code> is called when there is a need to reduce the overall capacity
  *             of a stream because of excess capacity that is not being used. You must specify the
  *             shard to be merged and the adjacent shard for a stream. For more information about
  *             merging shards, see <a href="https://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-resharding-merge.html">Merge Two
  *                 Shards</a> in the <i>Amazon Kinesis Data Streams Developer
  *                 Guide</i>.</p>
- *         <p>If the stream is in the <code>ACTIVE</code> state, you can call
+ *          <p>If the stream is in the <code>ACTIVE</code> state, you can call
  *                 <code>MergeShards</code>. If a stream is in the <code>CREATING</code>,
  *                 <code>UPDATING</code>, or <code>DELETING</code> state, <code>MergeShards</code>
  *             returns a <code>ResourceInUseException</code>. If the specified stream does not exist,
  *                 <code>MergeShards</code> returns a <code>ResourceNotFoundException</code>. </p>
- *         <p>You can use <a>DescribeStreamSummary</a> to check the state of the stream,
+ *          <p>You can use <a>DescribeStreamSummary</a> to check the state of the stream,
  *             which is returned in <code>StreamStatus</code>.</p>
- *         <p>
+ *          <p>
  *             <code>MergeShards</code> is an asynchronous operation. Upon receiving a
  *                 <code>MergeShards</code> request, Amazon Kinesis Data Streams immediately returns a
  *             response and sets the <code>StreamStatus</code> to <code>UPDATING</code>. After the
  *             operation is completed, Kinesis Data Streams sets the <code>StreamStatus</code> to
  *                 <code>ACTIVE</code>. Read and write operations continue to work while the stream is
  *             in the <code>UPDATING</code> state. </p>
- *         <p>You use <a>DescribeStreamSummary</a> and the <a>ListShards</a>
+ *          <p>You use <a>DescribeStreamSummary</a> and the <a>ListShards</a>
  *             APIs to determine the shard IDs that are specified in the <code>MergeShards</code>
  *             request. </p>
- *         <p>If you try to operate on too many streams in parallel using <a>CreateStream</a>, <a>DeleteStream</a>, <code>MergeShards</code>,
+ *          <p>If you try to operate on too many streams in parallel using <a>CreateStream</a>, <a>DeleteStream</a>, <code>MergeShards</code>,
  *             or <a>SplitShard</a>, you receive a <code>LimitExceededException</code>. </p>
- *         <p>
+ *          <p>
  *             <code>MergeShards</code> has a limit of five transactions per second per account.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.

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

@@ -12,37 +12,41 @@ export interface PutRecordCommandOutput extends PutRecordOutput, __MetadataBeare
  *                 <code>PutRecord</code> to send data into the stream for real-time ingestion and
  *             subsequent processing, one record at a time. Each shard can support writes up to 1,000
  *             records per second, up to a maximum data write total of 1 MiB per second.</p>
- *         <p>You must specify the name of the stream that captures, stores, and transports the
+ *          <note>
+ *             <p>When invoking this API, it is recommended you use the <code>StreamARN</code> input
+ *                 parameter rather than the <code>StreamName</code> input parameter.</p>
+ *          </note>
+ *          <p>You must specify the name of the stream that captures, stores, and transports the
  *             data; a partition key; and the data blob itself.</p>
- *         <p>The data blob can be any type of data; for example, a segment from a log file,
+ *          <p>The data blob can be any type of data; for example, a segment from a log file,
  *             geographic/location data, website clickstream data, and so on.</p>
- *         <p>The partition key is used by Kinesis Data Streams to distribute data across shards.
+ *          <p>The partition key is used by Kinesis Data Streams to distribute data across shards.
  *             Kinesis Data Streams segregates the data records that belong to a stream into multiple
  *             shards, using the partition key associated with each data record to determine the shard
  *             to which a given data record belongs.</p>
- *         <p>Partition keys are Unicode strings, with a maximum length limit of 256 characters for
+ *          <p>Partition keys are Unicode strings, with a maximum length limit of 256 characters for
  *             each key. An MD5 hash function is used to map partition keys to 128-bit integer values
  *             and to map associated data records to shards using the hash key ranges of the shards.
  *             You can override hashing the partition key to determine the shard by explicitly
  *             specifying a hash value using the <code>ExplicitHashKey</code> parameter. For more
  *             information, see <a href="https://docs.aws.amazon.com/kinesis/latest/dev/developing-producers-with-sdk.html#kinesis-using-sdk-java-add-data-to-stream">Adding Data to a Stream</a> in the <i>Amazon Kinesis Data Streams
  *                 Developer Guide</i>.</p>
- *         <p>
+ *          <p>
  *             <code>PutRecord</code> returns the shard ID of where the data record was placed and the
  *             sequence number that was assigned to the data record.</p>
- *         <p>Sequence numbers increase over time and are specific to a shard within a stream, not
+ *          <p>Sequence numbers increase over time and are specific to a shard within a stream, not
  *             across all shards within a stream. To guarantee strictly increasing ordering, write
  *             serially to a shard and use the <code>SequenceNumberForOrdering</code> parameter. For
  *             more information, see <a href="https://docs.aws.amazon.com/kinesis/latest/dev/developing-producers-with-sdk.html#kinesis-using-sdk-java-add-data-to-stream">Adding Data to a Stream</a> in the <i>Amazon Kinesis Data Streams
  *                 Developer Guide</i>.</p>
- *         <important>
+ *          <important>
  *             <p>After you write a record to a stream, you cannot modify that record or its order
  *                 within the stream.</p>
- *         </important>
- *         <p>If a <code>PutRecord</code> request cannot be processed because of insufficient
+ *          </important>
+ *          <p>If a <code>PutRecord</code> request cannot be processed because of insufficient
  *             provisioned throughput on the shard involved in the request, <code>PutRecord</code>
  *             throws <code>ProvisionedThroughputExceededException</code>. </p>
- *         <p>By default, data records are accessible for 24 hours from the time that they are added
+ *          <p>By default, data records are accessible for 24 hours from the time that they are added
  *             to a stream. You can use <a>IncreaseStreamRetentionPeriod</a> or <a>DecreaseStreamRetentionPeriod</a> to modify this retention period.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.