@aws-sdk/client-kinesis 3.40.0 → 3.44.0

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

@@ -17,38 +17,36 @@ export interface SplitShardCommandOutput extends __MetadataBearer {
  *                 <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 the shard where the shard gets split in two. In many cases, the new hash key might be
+ *         <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>DescribeStream</a> 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>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>
  *             <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 <code>DescribeStream</code> 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>. If a stream is in <code>CREATING</code> or
- *                 <code>UPDATING</code> or <code>DELETING</code> states, <code>DescribeStream</code>
- *             returns a <code>ResourceInUseException</code>.</p>
- *         <p>If the specified stream does not exist, <code>DescribeStream</code> 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 AWS 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 AWS
- *             Support</a>.</p>
+ *         <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>
+ *             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
+ *                 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
  *                 <code>LimitExceededException</code>. </p>
  *         <p>
- *             <code>SplitShard</code> has a limit of five transactions per second per
- *             account.</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.
  * ```javascript
@@ -61,7 +59,7 @@ export interface SplitShardCommandOutput extends __MetadataBearer {
  *
  * @see {@link SplitShardCommandInput} for command's `input` shape.
  * @see {@link SplitShardCommandOutput} for command's `response` shape.
- * @see {@link KinesisClientResolvedConfig | config} for command's `input` shape.
+ * @see {@link KinesisClientResolvedConfig | config} for KinesisClient's `config` shape.
  *
  */
 export declare class SplitShardCommand extends $Command<SplitShardCommandInput, SplitShardCommandOutput, KinesisClientResolvedConfig> {

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

@@ -7,22 +7,22 @@ export interface StartStreamEncryptionCommandInput extends StartStreamEncryption
 export interface StartStreamEncryptionCommandOutput extends __MetadataBearer {
 }
 /**
- * <p>Enables or updates server-side encryption using an AWS KMS key for a specified
- *             stream. </p>
- *         <p>Starting encryption is an asynchronous operation. Upon receiving the request,
- *             Kinesis Data Streams returns immediately and sets the status of the stream to
+ * <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
+ *             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
  *             normally takes a few seconds to complete, but it can take minutes. You can continue to
  *             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 AWS 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 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>
+ *         <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
+ *             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>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript
@@ -35,7 +35,7 @@ export interface StartStreamEncryptionCommandOutput extends __MetadataBearer {
  *
  * @see {@link StartStreamEncryptionCommandInput} for command's `input` shape.
  * @see {@link StartStreamEncryptionCommandOutput} for command's `response` shape.
- * @see {@link KinesisClientResolvedConfig | config} for command's `input` shape.
+ * @see {@link KinesisClientResolvedConfig | config} for KinesisClient's `config` shape.
  *
  */
 export declare class StartStreamEncryptionCommand extends $Command<StartStreamEncryptionCommandInput, StartStreamEncryptionCommandOutput, KinesisClientResolvedConfig> {

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

@@ -8,21 +8,20 @@ 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 Data Streams returns immediately and sets the status of the stream to
+ *         <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
  *             few seconds to complete, but it can take minutes. You can continue to read and write
  *             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 24-hour period. </p>
- *         <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>
+ *         <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
+ *             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>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript
@@ -35,7 +34,7 @@ export interface StopStreamEncryptionCommandOutput extends __MetadataBearer {
  *
  * @see {@link StopStreamEncryptionCommandInput} for command's `input` shape.
  * @see {@link StopStreamEncryptionCommandOutput} for command's `response` shape.
- * @see {@link KinesisClientResolvedConfig | config} for command's `input` shape.
+ * @see {@link KinesisClientResolvedConfig | config} for KinesisClient's `config` shape.
  *
  */
 export declare class StopStreamEncryptionCommand extends $Command<StopStreamEncryptionCommandInput, StopStreamEncryptionCommandOutput, KinesisClientResolvedConfig> {

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

@@ -25,8 +25,9 @@ export interface SubscribeToShardCommandOutput extends SubscribeToShardOutput, _
  *         <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 first connection will expire and the second
- *             call will take over the subscription.</p>
+ *             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
  *                 Using the Kinesis Data Streams API</a>.</p>
  * @example
@@ -41,7 +42,7 @@ export interface SubscribeToShardCommandOutput extends SubscribeToShardOutput, _
  *
  * @see {@link SubscribeToShardCommandInput} for command's `input` shape.
  * @see {@link SubscribeToShardCommandOutput} for command's `response` shape.
- * @see {@link KinesisClientResolvedConfig | config} for command's `input` shape.
+ * @see {@link KinesisClientResolvedConfig | config} for KinesisClient's `config` shape.
  *
  */
 export declare class SubscribeToShardCommand extends $Command<SubscribeToShardCommandInput, SubscribeToShardCommandOutput, KinesisClientResolvedConfig> {

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

@@ -19,8 +19,8 @@ export interface UpdateShardCountCommandOutput extends UpdateShardCountOutput, _
  *             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 a multiple of 25% (25%, 50%, 75%, 100%). You can specify any target value within your
+ *         <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
@@ -30,27 +30,26 @@ export interface UpdateShardCountCommandOutput extends UpdateShardCountOutput, _
  *                 <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>
  *             </li>
  *             <li>
- *                 <p>Scale up to more than 500 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 500 shards down unless the result is less
- *                     than 500 shards</p>
+ *                 <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>
  *             </li>
  *          </ul>
- *         <p>For the default limits for an AWS 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>
+ *         <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>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript
@@ -63,7 +62,7 @@ export interface UpdateShardCountCommandOutput extends UpdateShardCountOutput, _
  *
  * @see {@link UpdateShardCountCommandInput} for command's `input` shape.
  * @see {@link UpdateShardCountCommandOutput} for command's `response` shape.
- * @see {@link KinesisClientResolvedConfig | config} for command's `input` shape.
+ * @see {@link KinesisClientResolvedConfig | config} for KinesisClient's `config` shape.
  *
  */
 export declare class UpdateShardCountCommand extends $Command<UpdateShardCountCommandInput, UpdateShardCountCommandOutput, KinesisClientResolvedConfig> {

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

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { KinesisClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KinesisClient";
+import { UpdateStreamModeInput } from "../models/models_0";
+export interface UpdateStreamModeCommandInput extends UpdateStreamModeInput {
+}
+export interface UpdateStreamModeCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p> Updates the capacity mode of the data stream. Currently, in Kinesis Data Streams, you
+ *             can choose between an <b>on-demand</b> capacity mode and a
+ *                 <b>provisioned</b> capacity mode for your data stream.
+ *         </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { KinesisClient, UpdateStreamModeCommand } from "@aws-sdk/client-kinesis"; // ES Modules import
+ * // const { KinesisClient, UpdateStreamModeCommand } = require("@aws-sdk/client-kinesis"); // CommonJS import
+ * const client = new KinesisClient(config);
+ * const command = new UpdateStreamModeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateStreamModeCommandInput} for command's `input` shape.
+ * @see {@link UpdateStreamModeCommandOutput} for command's `response` shape.
+ * @see {@link KinesisClientResolvedConfig | config} for KinesisClient's `config` shape.
+ *
+ */
+export declare class UpdateStreamModeCommand extends $Command<UpdateStreamModeCommandInput, UpdateStreamModeCommandOutput, KinesisClientResolvedConfig> {
+    readonly input: UpdateStreamModeCommandInput;
+    constructor(input: UpdateStreamModeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateStreamModeCommandInput, UpdateStreamModeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -26,3 +26,4 @@ export * from "./StartStreamEncryptionCommand";
 export * from "./StopStreamEncryptionCommand";
 export * from "./SubscribeToShardCommand";
 export * from "./UpdateShardCountCommand";
+export * from "./UpdateStreamModeCommand";