@aws-sdk/client-kinesis 3.36.0 → 3.39.0

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

@@ -6,34 +6,11 @@ export interface RemoveTagsFromStreamCommandInput extends RemoveTagsFromStreamIn
 }
 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>
- *             <a>RemoveTagsFromStream</a> 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
- * import { KinesisClient, RemoveTagsFromStreamCommand } from "@aws-sdk/client-kinesis"; // ES Modules import
- * // const { KinesisClient, RemoveTagsFromStreamCommand } = require("@aws-sdk/client-kinesis"); // CommonJS import
- * const client = new KinesisClient(config);
- * const command = new RemoveTagsFromStreamCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RemoveTagsFromStreamCommandInput} for command's `input` shape.
- * @see {@link RemoveTagsFromStreamCommandOutput} for command's `response` shape.
- * @see {@link KinesisClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RemoveTagsFromStreamCommand extends $Command<RemoveTagsFromStreamCommandInput, RemoveTagsFromStreamCommandOutput, KinesisClientResolvedConfig> {
     readonly input: RemoveTagsFromStreamCommandInput;
     constructor(input: RemoveTagsFromStreamCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RemoveTagsFromStreamCommandInput, RemoveTagsFromStreamCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,70 +6,11 @@ export interface SplitShardCommandInput extends SplitShardInput {
 }
 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
- *             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 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>
- *             <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>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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisClient, SplitShardCommand } from "@aws-sdk/client-kinesis"; // ES Modules import
- * // const { KinesisClient, SplitShardCommand } = require("@aws-sdk/client-kinesis"); // CommonJS import
- * const client = new KinesisClient(config);
- * const command = new SplitShardCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @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.
- *
- */
+
 export declare class SplitShardCommand extends $Command<SplitShardCommandInput, SplitShardCommandOutput, KinesisClientResolvedConfig> {
     readonly input: SplitShardCommandInput;
     constructor(input: SplitShardCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SplitShardCommandInput, SplitShardCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,44 +6,11 @@ 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
- *                 <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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisClient, StartStreamEncryptionCommand } from "@aws-sdk/client-kinesis"; // ES Modules import
- * // const { KinesisClient, StartStreamEncryptionCommand } = require("@aws-sdk/client-kinesis"); // CommonJS import
- * const client = new KinesisClient(config);
- * const command = new StartStreamEncryptionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @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.
- *
- */
+
 export declare class StartStreamEncryptionCommand extends $Command<StartStreamEncryptionCommandInput, StartStreamEncryptionCommandOutput, KinesisClientResolvedConfig> {
     readonly input: StartStreamEncryptionCommandInput;
     constructor(input: StartStreamEncryptionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartStreamEncryptionCommandInput, StartStreamEncryptionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,44 +6,11 @@ export interface StopStreamEncryptionCommandInput extends StopStreamEncryptionIn
 }
 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
- *                 <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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisClient, StopStreamEncryptionCommand } from "@aws-sdk/client-kinesis"; // ES Modules import
- * // const { KinesisClient, StopStreamEncryptionCommand } = require("@aws-sdk/client-kinesis"); // CommonJS import
- * const client = new KinesisClient(config);
- * const command = new StopStreamEncryptionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @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.
- *
- */
+
 export declare class StopStreamEncryptionCommand extends $Command<StopStreamEncryptionCommandInput, StopStreamEncryptionCommandOutput, KinesisClientResolvedConfig> {
     readonly input: StopStreamEncryptionCommandInput;
     constructor(input: StopStreamEncryptionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopStreamEncryptionCommandInput, StopStreamEncryptionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,50 +6,11 @@ export interface SubscribeToShardCommandInput extends SubscribeToShardInput {
 }
 export interface SubscribeToShardCommandOutput extends SubscribeToShardOutput, __MetadataBearer {
 }
-/**
- * <p>This operation establishes an HTTP/2 connection between the consumer you specify in
- *             the <code>ConsumerARN</code> parameter and the shard you specify in the
- *                 <code>ShardId</code> parameter. After the connection is successfully established,
- *             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
- *             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
- *             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>
- *             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>
- *         <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.
- * ```javascript
- * import { KinesisClient, SubscribeToShardCommand } from "@aws-sdk/client-kinesis"; // ES Modules import
- * // const { KinesisClient, SubscribeToShardCommand } = require("@aws-sdk/client-kinesis"); // CommonJS import
- * const client = new KinesisClient(config);
- * const command = new SubscribeToShardCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @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.
- *
- */
+
 export declare class SubscribeToShardCommand extends $Command<SubscribeToShardCommandInput, SubscribeToShardCommandOutput, KinesisClientResolvedConfig> {
     readonly input: SubscribeToShardCommandInput;
     constructor(input: SubscribeToShardCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SubscribeToShardCommandInput, SubscribeToShardCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,72 +6,11 @@ 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,
- *             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
- *             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
- *             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
- *             following:</p>
- *         <ul>
- *             <li>
- *                 <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>
- *             </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>
- *             </li>
- *             <li>
- *                 <p>Scale a stream with more than 500 shards down unless the result is less
- *                     than 500 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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisClient, UpdateShardCountCommand } from "@aws-sdk/client-kinesis"; // ES Modules import
- * // const { KinesisClient, UpdateShardCountCommand } = require("@aws-sdk/client-kinesis"); // CommonJS import
- * const client = new KinesisClient(config);
- * const command = new UpdateShardCountCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @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.
- *
- */
+
 export declare class UpdateShardCountCommand extends $Command<UpdateShardCountCommandInput, UpdateShardCountCommandOutput, KinesisClientResolvedConfig> {
     readonly input: UpdateShardCountCommandInput;
     constructor(input: UpdateShardCountCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateShardCountCommandInput, UpdateShardCountCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -0,0 +1,28 @@
+export * from "./AddTagsToStreamCommand";
+export * from "./CreateStreamCommand";
+export * from "./DecreaseStreamRetentionPeriodCommand";
+export * from "./DeleteStreamCommand";
+export * from "./DeregisterStreamConsumerCommand";
+export * from "./DescribeLimitsCommand";
+export * from "./DescribeStreamCommand";
+export * from "./DescribeStreamConsumerCommand";
+export * from "./DescribeStreamSummaryCommand";
+export * from "./DisableEnhancedMonitoringCommand";
+export * from "./EnableEnhancedMonitoringCommand";
+export * from "./GetRecordsCommand";
+export * from "./GetShardIteratorCommand";
+export * from "./IncreaseStreamRetentionPeriodCommand";
+export * from "./ListShardsCommand";
+export * from "./ListStreamConsumersCommand";
+export * from "./ListStreamsCommand";
+export * from "./ListTagsForStreamCommand";
+export * from "./MergeShardsCommand";
+export * from "./PutRecordCommand";
+export * from "./PutRecordsCommand";
+export * from "./RegisterStreamConsumerCommand";
+export * from "./RemoveTagsFromStreamCommand";
+export * from "./SplitShardCommand";
+export * from "./StartStreamEncryptionCommand";
+export * from "./StopStreamEncryptionCommand";
+export * from "./SubscribeToShardCommand";
+export * from "./UpdateShardCountCommand";

package/dist-types/ts3.4/index.d.ts

@@ -1,35 +1,6 @@
-export * from "./KinesisClient";
 export * from "./Kinesis";
-export * from "./commands/AddTagsToStreamCommand";
-export * from "./commands/CreateStreamCommand";
-export * from "./commands/DecreaseStreamRetentionPeriodCommand";
-export * from "./commands/DeleteStreamCommand";
-export * from "./commands/DeregisterStreamConsumerCommand";
-export * from "./commands/DescribeLimitsCommand";
-export * from "./commands/DescribeStreamCommand";
-export * from "./waiters/waitForStreamExists";
-export * from "./waiters/waitForStreamNotExists";
-export * from "./commands/DescribeStreamConsumerCommand";
-export * from "./commands/DescribeStreamSummaryCommand";
-export * from "./commands/DisableEnhancedMonitoringCommand";
-export * from "./commands/EnableEnhancedMonitoringCommand";
-export * from "./commands/GetRecordsCommand";
-export * from "./commands/GetShardIteratorCommand";
-export * from "./commands/IncreaseStreamRetentionPeriodCommand";
-export * from "./commands/ListShardsCommand";
-export * from "./commands/ListStreamConsumersCommand";
-export * from "./pagination/ListStreamConsumersPaginator";
-export * from "./commands/ListStreamsCommand";
-export * from "./commands/ListTagsForStreamCommand";
-export * from "./commands/MergeShardsCommand";
-export * from "./commands/PutRecordCommand";
-export * from "./commands/PutRecordsCommand";
-export * from "./commands/RegisterStreamConsumerCommand";
-export * from "./commands/RemoveTagsFromStreamCommand";
-export * from "./commands/SplitShardCommand";
-export * from "./commands/StartStreamEncryptionCommand";
-export * from "./commands/StopStreamEncryptionCommand";
-export * from "./commands/SubscribeToShardCommand";
-export * from "./commands/UpdateShardCountCommand";
-export * from "./pagination/Interfaces";
-export * from "./models/index";
+export * from "./KinesisClient";
+export * from "./commands";
+export * from "./models";
+export * from "./pagination";
+export * from "./waiters";