@aws-sdk/client-kinesis 3.231.0 → 3.232.0

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

@@ -11,45 +11,49 @@ export interface PutRecordsCommandOutput extends PutRecordsOutput, __MetadataBea
  * <p>Writes multiple data records into a Kinesis data stream in a single call (also
  *             referred to as a <code>PutRecords</code> request). Use this operation to send data into
  *             the stream for data ingestion and processing. </p>
- *         <p>Each <code>PutRecords</code> request can support up to 500 records. Each record in 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>Each <code>PutRecords</code> request can support up to 500 records. Each record in the
  *             request can be as large as 1 MiB, up to a limit of 5 MiB for the entire request,
  *             including partition keys. 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
+ *          <p>You must specify the name of the stream that captures, stores, and transports the
  *             data; and an array of request <code>Records</code>, with each record in the array
  *             requiring a partition key and data blob. The record size limit applies to the total size
  *             of the partition key and data blob.</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 as input to a hash function that
+ *          <p>The partition key is used by Kinesis Data Streams as input to a hash function that
  *             maps the partition key and associated data to a specific shard. An MD5 hash function is
  *             used to map partition keys to 128-bit integer values and to map associated data records
  *             to shards. As a result of this hashing mechanism, all data records with the same
  *             partition key map to the same shard within the stream. 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>Each record in the <code>Records</code> array may include an optional parameter,
+ *          <p>Each record in the <code>Records</code> array may include an optional parameter,
  *                 <code>ExplicitHashKey</code>, which overrides the partition key to shard mapping.
  *             This parameter allows a data producer to determine explicitly the shard where the record
  *             is stored. For more information, see <a href="https://docs.aws.amazon.com/kinesis/latest/dev/developing-producers-with-sdk.html#kinesis-using-sdk-java-putrecords">Adding Multiple Records with PutRecords</a> in the <i>Amazon Kinesis
  *                 Data Streams Developer Guide</i>.</p>
- *         <p>The <code>PutRecords</code> response includes an array of response
+ *          <p>The <code>PutRecords</code> response includes an array of response
  *                 <code>Records</code>. Each record in the response array directly correlates with a
  *             record in the request array using natural ordering, from the top to the bottom of the
  *             request and response. The response <code>Records</code> array always includes the same
  *             number of records as the request array.</p>
- *         <p>The response <code>Records</code> array includes both successfully and unsuccessfully
+ *          <p>The response <code>Records</code> array includes both successfully and unsuccessfully
  *             processed records. Kinesis Data Streams attempts to process all records in each
  *                 <code>PutRecords</code> request. A single record failure does not stop the
  *             processing of subsequent records. As a result, PutRecords doesn't guarantee the ordering
  *             of records. If you need to read records in the same order they are written to the
  *             stream, use <a>PutRecord</a> instead of <code>PutRecords</code>, and write to
  *             the same shard.</p>
- *         <p>A successfully processed record includes <code>ShardId</code> and
+ *          <p>A successfully processed record includes <code>ShardId</code> and
  *                 <code>SequenceNumber</code> values. The <code>ShardId</code> parameter identifies
  *             the shard in the stream where the record is stored. The <code>SequenceNumber</code>
  *             parameter is an identifier assigned to the put record, unique to all records in the
  *             stream.</p>
- *         <p>An unsuccessfully processed record includes <code>ErrorCode</code> and
+ *          <p>An unsuccessfully processed record includes <code>ErrorCode</code> and
  *                 <code>ErrorMessage</code> values. <code>ErrorCode</code> reflects the type of error
  *             and can be one of the following values:
  *                 <code>ProvisionedThroughputExceededException</code> or <code>InternalFailure</code>.
@@ -58,11 +62,11 @@ export interface PutRecordsCommandOutput extends PutRecordsOutput, __MetadataBea
  *             ID, stream name, and shard ID of the record that was throttled. For more information
  *             about partially successful responses, see <a href="https://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-add-data-to-stream.html#kinesis-using-sdk-java-putrecords">Adding Multiple Records with PutRecords</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>By default, data records are accessible for 24 hours from the time that they are added
+ *          </important>
+ *          <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.

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

@@ -13,11 +13,11 @@ export interface RegisterStreamConsumerCommandOutput extends RegisterStreamConsu
  *             from the stream using enhanced fan-out, at a rate of up to 2 MiB per second for every
  *             shard you subscribe to. This rate is unaffected by the total number of consumers that
  *             read from the same stream.</p>
- *         <p>You can register up to 20 consumers per stream. A given consumer can only be
+ *          <p>You can register up to 20 consumers per stream. A given consumer can only be
  *             registered with one stream at a time.</p>
- *         <p>For an example of how to use this operations, see <a href="/streams/latest/dev/building-enhanced-consumers-api.html">Enhanced Fan-Out
+ *          <p>For an example of how to use this operations, see <a href="/streams/latest/dev/building-enhanced-consumers-api.html">Enhanced Fan-Out
  *                 Using the Kinesis Data Streams API</a>.</p>
- *         <p>The use of this operation has a limit of five transactions per second per account.
+ *          <p>The use of this operation has a limit of five transactions per second per account.
  *             Also, only 5 consumers can be created simultaneously. In other words, you cannot have
  *             more than 5 consumers in a <code>CREATING</code> status at the same time. Registering a
  *             6th consumer while there are 5 in a <code>CREATING</code> status results in a

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

@@ -10,8 +10,12 @@ export interface RemoveTagsFromStreamCommandOutput extends __MetadataBearer {
 /**
  * <p>Removes tags from the specified Kinesis data stream. Removed tags are deleted and
  *             cannot be recovered after this operation successfully completes.</p>
- *         <p>If you specify a tag that does not exist, it is ignored.</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>If you specify a tag that does not exist, it is ignored.</p>
+ *          <p>
  *             <a>RemoveTagsFromStream</a> has a limit of five transactions per second per
  *             account.</p>
  * @example

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

@@ -11,42 +11,47 @@ export interface SplitShardCommandOutput extends __MetadataBearer {
  * <p>Splits a shard into two new shards in the Kinesis data stream, to increase the
  *             stream's capacity to ingest and transport data. <code>SplitShard</code> is called when
  *             there is a need to increase the overall capacity of a stream because of an expected
- *             increase in the volume of data records being ingested. </p>
- *         <p>You can also use <code>SplitShard</code> when a shard appears to be approaching its
+ *             increase in the volume of data records being ingested. This API is only supported for
+ *             the data streams with the provisioned capacity mode.</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>You can also use <code>SplitShard</code> when a shard appears to be approaching its
  *             maximum utilization; for example, the producers sending data into the specific shard are
  *             suddenly sending more than previously anticipated. You can also call
  *                 <code>SplitShard</code> to increase stream capacity, so that more Kinesis Data
  *             Streams applications can simultaneously read data from the stream for real-time
  *             processing. </p>
- *         <p>You must specify the shard to be split and the new hash key, which is the position in
+ *          <p>You must specify the shard to be split and the new hash key, which is the position in
  *             the shard where the shard gets split in two. In many cases, the new hash key might be
  *             the average of the beginning and ending hash key, but it can be any hash key value in
  *             the range being mapped into the shard. For more information, see <a href="https://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-resharding-split.html">Split a
  *                 Shard</a> in the <i>Amazon Kinesis Data Streams Developer
  *                 Guide</i>.</p>
- *         <p>You can use <a>DescribeStreamSummary</a> and the <a>ListShards</a> APIs to determine the shard ID and hash key values for the <code>ShardToSplit</code>
+ *          <p>You can use <a>DescribeStreamSummary</a> and the <a>ListShards</a> APIs to determine the shard ID and hash key values for the <code>ShardToSplit</code>
  *             and <code>NewStartingHashKey</code> parameters that are specified in the
  *                 <code>SplitShard</code> request.</p>
- *         <p>
+ *          <p>
  *             <code>SplitShard</code> is an asynchronous operation. Upon receiving a
  *                 <code>SplitShard</code> request, Kinesis Data Streams immediately returns a response
  *             and sets the stream status to <code>UPDATING</code>. After the operation is completed,
  *             Kinesis Data Streams sets the stream status to <code>ACTIVE</code>. Read and write
  *             operations continue to work while the stream is in the <code>UPDATING</code> state. </p>
- *         <p>You can use <a>DescribeStreamSummary</a> to check the status of the stream,
+ *          <p>You can use <a>DescribeStreamSummary</a> to check the status of the stream,
  *             which is returned in <code>StreamStatus</code>. If the stream is in the
  *                 <code>ACTIVE</code> state, you can call <code>SplitShard</code>.
  *             </p>
- *         <p>If the specified stream does not exist, <a>DescribeStreamSummary</a>
+ *          <p>If the specified stream does not exist, <a>DescribeStreamSummary</a>
  *             returns a <code>ResourceNotFoundException</code>. If you try to create more shards than
  *             are authorized for your account, you receive a <code>LimitExceededException</code>. </p>
- *         <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">Kinesis
+ *          <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">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>If you try to operate on too many streams simultaneously using <a>CreateStream</a>, <a>DeleteStream</a>, <a>MergeShards</a>, and/or <a>SplitShard</a>, you receive a
+ *          <p>If you try to operate on too many streams simultaneously using <a>CreateStream</a>, <a>DeleteStream</a>, <a>MergeShards</a>, and/or <a>SplitShard</a>, you receive a
  *                 <code>LimitExceededException</code>. </p>
- *         <p>
+ *          <p>
  *             <code>SplitShard</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/StartStreamEncryptionCommand.d.ts

@@ -10,7 +10,7 @@ export interface StartStreamEncryptionCommandOutput extends __MetadataBearer {
 /**
  * <p>Enables or updates server-side encryption using an Amazon Web Services KMS key for a
  *             specified stream. </p>
- *         <p>Starting encryption is an asynchronous operation. Upon receiving the request, Kinesis
+ *          <p>Starting encryption is an asynchronous operation. Upon receiving the request, Kinesis
  *             Data Streams returns immediately and sets the status of the stream to
  *                 <code>UPDATING</code>. After the update is complete, Kinesis Data Streams sets the
  *             status of the stream back to <code>ACTIVE</code>. Updating or applying encryption
@@ -18,12 +18,16 @@ export interface StartStreamEncryptionCommandOutput extends __MetadataBearer {
  *             read and write data to your stream while its status is <code>UPDATING</code>. Once the
  *             status of the stream is <code>ACTIVE</code>, encryption begins for records written to
  *             the stream. </p>
- *         <p>API Limits: You can successfully apply a new Amazon Web Services KMS key for
+ *          <p>API Limits: You can successfully apply a new Amazon Web Services KMS key for
  *             server-side encryption 25 times in a rolling 24-hour period.</p>
- *         <p>Note: It can take up to 5 seconds after the stream is in an <code>ACTIVE</code> status
+ *          <p>Note: It can take up to 5 seconds after the stream is in an <code>ACTIVE</code> status
  *             before all records written to the stream are encrypted. After you enable encryption, you
  *             can verify that encryption is applied by inspecting the API response from
  *                 <code>PutRecord</code> or <code>PutRecords</code>.</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/StopStreamEncryptionCommand.d.ts

@@ -9,7 +9,11 @@ export interface StopStreamEncryptionCommandOutput extends __MetadataBearer {
 }
 /**
  * <p>Disables server-side encryption for a specified stream. </p>
- *         <p>Stopping encryption is an asynchronous operation. Upon receiving the request, Kinesis
+ *          <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>Stopping encryption is an asynchronous operation. Upon receiving the request, Kinesis
  *             Data Streams returns immediately and sets the status of the stream to
  *                 <code>UPDATING</code>. After the update is complete, Kinesis Data Streams sets the
  *             status of the stream back to <code>ACTIVE</code>. Stopping encryption normally takes a
@@ -17,9 +21,9 @@ export interface StopStreamEncryptionCommandOutput extends __MetadataBearer {
  *             data to your stream while its status is <code>UPDATING</code>. Once the status of the
  *             stream is <code>ACTIVE</code>, records written to the stream are no longer encrypted by
  *             Kinesis Data Streams. </p>
- *         <p>API Limits: You can successfully disable server-side encryption 25 times in a rolling
+ *          <p>API Limits: You can successfully disable server-side encryption 25 times in a rolling
  *             24-hour period. </p>
- *         <p>Note: It can take up to 5 seconds after the stream is in an <code>ACTIVE</code> status
+ *          <p>Note: It can take up to 5 seconds after the stream is in an <code>ACTIVE</code> status
  *             before all records written to the stream are no longer subject to encryption. After you
  *             disabled encryption, you can verify that encryption is not applied by inspecting the API
  *             response from <code>PutRecord</code> or <code>PutRecords</code>.</p>

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

@@ -14,22 +14,22 @@ export interface SubscribeToShardCommandOutput extends SubscribeToShardOutput, _
  *             Kinesis Data Streams pushes records from the shard to the consumer over this connection.
  *             Before you call this operation, call <a>RegisterStreamConsumer</a> to
  *             register the consumer with Kinesis Data Streams.</p>
- *         <p>When the <code>SubscribeToShard</code> call succeeds, your consumer starts receiving
+ *          <p>When the <code>SubscribeToShard</code> call succeeds, your consumer starts receiving
  *             events of type <a>SubscribeToShardEvent</a> over the HTTP/2 connection for up
  *             to 5 minutes, after which time you need to call <code>SubscribeToShard</code> again to
  *             renew the subscription if you want to continue to receive records.</p>
- *         <p>You can make one call to <code>SubscribeToShard</code> per second per registered
+ *          <p>You can make one call to <code>SubscribeToShard</code> per second per registered
  *             consumer per shard. For example, if you have a 4000 shard stream and two registered
  *             stream consumers, you can make one <code>SubscribeToShard</code> request per second for
  *             each combination of shard and registered consumer, allowing you to subscribe both
  *             consumers to all 4000 shards in one second. </p>
- *         <p>If you call <code>SubscribeToShard</code> again with the same <code>ConsumerARN</code>
+ *          <p>If you call <code>SubscribeToShard</code> again with the same <code>ConsumerARN</code>
  *             and <code>ShardId</code> within 5 seconds of a successful call, you'll get a
  *                 <code>ResourceInUseException</code>. If you call <code>SubscribeToShard</code> 5
  *             seconds or more after a successful call, the second call takes over the subscription and
  *             the previous connection expires or fails with a
  *             <code>ResourceInUseException</code>.</p>
- *         <p>For an example of how to use this operations, see <a href="/streams/latest/dev/building-enhanced-consumers-api.html">Enhanced Fan-Out
+ *          <p>For an example of how to use this operations, see <a href="/streams/latest/dev/building-enhanced-consumers-api.html">Enhanced Fan-Out
  *                 Using the Kinesis Data Streams API</a>.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.

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

@@ -8,46 +8,51 @@ export interface UpdateShardCountCommandInput extends UpdateShardCountInput {
 export interface UpdateShardCountCommandOutput extends UpdateShardCountOutput, __MetadataBearer {
 }
 /**
- * <p>Updates the shard count of the specified stream to the specified number of
- *             shards.</p>
- *         <p>Updating the shard count is an asynchronous operation. Upon receiving the request,
+ * <p>Updates the shard count of the specified stream to the specified number of shards.
+ *             This API is only supported for the data streams with the provisioned capacity
+ *             mode.</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>Updating the shard count is an asynchronous operation. Upon receiving the request,
  *             Kinesis Data Streams returns immediately and sets the status of the stream to
  *                 <code>UPDATING</code>. After the update is complete, Kinesis Data Streams sets the
  *             status of the stream back to <code>ACTIVE</code>. Depending on the size of the stream,
  *             the scaling action could take a few minutes to complete. You can continue to read and
  *             write data to your stream while its status is <code>UPDATING</code>.</p>
- *         <p>To update the shard count, Kinesis Data Streams performs splits or merges on
+ *          <p>To update the shard count, Kinesis Data Streams performs splits or merges on
  *             individual shards. This can cause short-lived shards to be created, in addition to the
  *             final shards. These short-lived shards count towards your total shard limit for your
  *             account in the Region.</p>
- *         <p>When using this operation, we recommend that you specify a target shard count that is
+ *          <p>When using this operation, we recommend that you specify a target shard count that is
  *             a multiple of 25% (25%, 50%, 75%, 100%). You can specify any target value within your
  *             shard limit. However, if you specify a target that isn't a multiple of 25%, the scaling
  *             action might take longer to complete. </p>
- *         <p>This operation has the following default limits. By default, you cannot do the
+ *          <p>This operation has the following default limits. By default, you cannot do the
  *             following:</p>
- *         <ul>
+ *          <ul>
  *             <li>
- *                 <p>Scale more than ten times per rolling 24-hour period per stream</p>
+ *                <p>Scale more than ten times per rolling 24-hour period per stream</p>
  *             </li>
  *             <li>
- *                 <p>Scale up to more than double your current shard count for a stream</p>
+ *                <p>Scale up to more than double your current shard count for a stream</p>
  *             </li>
  *             <li>
- *                 <p>Scale down below half your current shard count for a stream</p>
+ *                <p>Scale down below half your current shard count for a stream</p>
  *             </li>
  *             <li>
- *                 <p>Scale up to more than 10000 shards in a stream</p>
+ *                <p>Scale up to more than 10000 shards in a stream</p>
  *             </li>
  *             <li>
- *                 <p>Scale a stream with more than 10000 shards down unless the result is less than
+ *                <p>Scale a stream with more than 10000 shards down unless the result is less than
  *                     10000 shards</p>
  *             </li>
  *             <li>
- *                 <p>Scale up to more than the shard limit for your account</p>
+ *                <p>Scale up to more than the shard limit for your account</p>
  *             </li>
  *          </ul>
- *         <p>For the default limits for an Amazon Web Services account, see <a href="https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html">Streams
+ *          <p>For the default limits for an Amazon Web Services account, see <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>. To request an increase in the call rate limit, the shard limit for
  *             this API, or your overall shard limit, use the <a href="https://console.aws.amazon.com/support/v1#/case/create?issueType=service-limit-increase&limitType=service-code-kinesis">limits form</a>.</p>

package/dist-types/endpoint/EndpointParameters.d.ts

@@ -12,8 +12,11 @@ export declare const resolveClientEndpointParameters: <T>(options: T & ClientInp
     defaultSigningName: string;
 };
 export interface EndpointParameters extends __EndpointParameters {
-    Region?: string;
+    Region: string;
     UseDualStack?: boolean;
     UseFIPS?: boolean;
     Endpoint?: string;
+    StreamARN?: string;
+    OperationType?: string;
+    ConsumerARN?: string;
 }