@aws-sdk/client-kinesis 3.36.0 → 3.39.0

package/dist-cjs/commands/GetRecordsCommand.js

@@ -5,81 +5,11 @@ const middleware_serde_1 = require("@aws-sdk/middleware-serde");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
 const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
-/**
- * <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
- *             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
- *             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
- *             continuously from its stream. To read from a stream continually, call <a>GetRecords</a> in a loop. Use <a>GetShardIterator</a> to get the
- *             shard iterator to specify in the first <a>GetRecords</a> call. <a>GetRecords</a> returns a new shard iterator in
- *                 <code>NextShardIterator</code>. Specify the shard iterator returned in
- *                 <code>NextShardIterator</code> in subsequent calls to <a>GetRecords</a>.
- *             If the shard has been closed, the shard iterator can't return more data and <a>GetRecords</a> returns <code>null</code> in <code>NextShardIterator</code>.
- *             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 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 utilization of the shard. The maximum size of data that <a>GetRecords</a>
- *             can return is 10 MiB. If a call returns this amount of data, subsequent calls made
- *             within the next 5 seconds throw <code>ProvisionedThroughputExceededException</code>. If
- *             there is insufficient provisioned throughput on the stream, subsequent calls made within
- *             the next 1 second throw <code>ProvisionedThroughputExceededException</code>. <a>GetRecords</a> 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
- *                 <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>, 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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisClient, GetRecordsCommand } from "@aws-sdk/client-kinesis"; // ES Modules import
- * // const { KinesisClient, GetRecordsCommand } = require("@aws-sdk/client-kinesis"); // CommonJS import
- * const client = new KinesisClient(config);
- * const command = new GetRecordsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetRecordsCommandInput} for command's `input` shape.
- * @see {@link GetRecordsCommandOutput} for command's `response` shape.
- * @see {@link KinesisClientResolvedConfig | config} for command's `input` shape.
- *
- */
 class GetRecordsCommand extends smithy_client_1.Command {
-    // Start section: command_properties
-    // End section: command_properties
     constructor(input) {
-        // Start section: command_constructor
         super();
         this.input = input;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
         const stack = clientStack.concat(this.middlewareStack);

package/dist-cjs/commands/GetShardIteratorCommand.js

@@ -5,68 +5,11 @@ const middleware_serde_1 = require("@aws-sdk/middleware-serde");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
 const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
-/**
- * <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 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
- *                 <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
- *             using the <code>AFTER_SEQUENCE_NUMBER</code> shard iterator type, using sequence numbers
- *             returned by earlier calls to <a>PutRecord</a>, <a>PutRecords</a>,
- *                 <a>GetRecords</a>, or <a>DescribeStream</a>. In the request,
- *             you can specify the shard iterator type <code>AT_TIMESTAMP</code> to read records from
- *             an arbitrary point in time, <code>TRIM_HORIZON</code> to cause
- *                 <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>
- *             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
- *                 <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
- *             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>
- *             <a>GetShardIterator</a> has a limit of five transactions per second per
- *             account per open shard.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisClient, GetShardIteratorCommand } from "@aws-sdk/client-kinesis"; // ES Modules import
- * // const { KinesisClient, GetShardIteratorCommand } = require("@aws-sdk/client-kinesis"); // CommonJS import
- * const client = new KinesisClient(config);
- * const command = new GetShardIteratorCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetShardIteratorCommandInput} for command's `input` shape.
- * @see {@link GetShardIteratorCommandOutput} for command's `response` shape.
- * @see {@link KinesisClientResolvedConfig | config} for command's `input` shape.
- *
- */
 class GetShardIteratorCommand extends smithy_client_1.Command {
-    // Start section: command_properties
-    // End section: command_properties
     constructor(input) {
-        // Start section: command_constructor
         super();
         this.input = input;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
         const stack = clientStack.concat(this.middlewareStack);

package/dist-cjs/commands/IncreaseStreamRetentionPeriodCommand.js

@@ -5,43 +5,11 @@ const middleware_serde_1 = require("@aws-sdk/middleware-serde");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
 const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
-/**
- * <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 168 hours (7 days).</p>
- *         <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
- *             period is set to 24 hours and is increased to 168 hours, any data that is older than 24
- *             hours remains inaccessible to consumer applications.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisClient, IncreaseStreamRetentionPeriodCommand } from "@aws-sdk/client-kinesis"; // ES Modules import
- * // const { KinesisClient, IncreaseStreamRetentionPeriodCommand } = require("@aws-sdk/client-kinesis"); // CommonJS import
- * const client = new KinesisClient(config);
- * const command = new IncreaseStreamRetentionPeriodCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link IncreaseStreamRetentionPeriodCommandInput} for command's `input` shape.
- * @see {@link IncreaseStreamRetentionPeriodCommandOutput} for command's `response` shape.
- * @see {@link KinesisClientResolvedConfig | config} for command's `input` shape.
- *
- */
 class IncreaseStreamRetentionPeriodCommand extends smithy_client_1.Command {
-    // Start section: command_properties
-    // End section: command_properties
     constructor(input) {
-        // Start section: command_constructor
         super();
         this.input = input;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
         const stack = clientStack.concat(this.middlewareStack);

package/dist-cjs/commands/ListShardsCommand.js

@@ -5,43 +5,11 @@ const middleware_serde_1 = require("@aws-sdk/middleware-serde");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
 const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
-/**
- * <p>Lists the shards in a stream and provides information about each shard. This
- *             operation has a limit of 100 transactions per second per data stream.</p>
- *         <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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisClient, ListShardsCommand } from "@aws-sdk/client-kinesis"; // ES Modules import
- * // const { KinesisClient, ListShardsCommand } = require("@aws-sdk/client-kinesis"); // CommonJS import
- * const client = new KinesisClient(config);
- * const command = new ListShardsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListShardsCommandInput} for command's `input` shape.
- * @see {@link ListShardsCommandOutput} for command's `response` shape.
- * @see {@link KinesisClientResolvedConfig | config} for command's `input` shape.
- *
- */
 class ListShardsCommand extends smithy_client_1.Command {
-    // Start section: command_properties
-    // End section: command_properties
     constructor(input) {
-        // Start section: command_constructor
         super();
         this.input = input;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
         const stack = clientStack.concat(this.middlewareStack);

package/dist-cjs/commands/ListStreamConsumersCommand.js

@@ -5,37 +5,11 @@ const middleware_serde_1 = require("@aws-sdk/middleware-serde");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
 const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
-/**
- * <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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisClient, ListStreamConsumersCommand } from "@aws-sdk/client-kinesis"; // ES Modules import
- * // const { KinesisClient, ListStreamConsumersCommand } = require("@aws-sdk/client-kinesis"); // CommonJS import
- * const client = new KinesisClient(config);
- * const command = new ListStreamConsumersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListStreamConsumersCommandInput} for command's `input` shape.
- * @see {@link ListStreamConsumersCommandOutput} for command's `response` shape.
- * @see {@link KinesisClientResolvedConfig | config} for command's `input` shape.
- *
- */
 class ListStreamConsumersCommand extends smithy_client_1.Command {
-    // Start section: command_properties
-    // End section: command_properties
     constructor(input) {
-        // Start section: command_constructor
         super();
         this.input = input;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
         const stack = clientStack.concat(this.middlewareStack);

package/dist-cjs/commands/ListStreamsCommand.js

@@ -5,50 +5,11 @@ const middleware_serde_1 = require("@aws-sdk/middleware-serde");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
 const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
-/**
- * <p>Lists your Kinesis data streams.</p>
- *         <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 10.</p>
- *         <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>
- *             <a>ListStreams</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, ListStreamsCommand } from "@aws-sdk/client-kinesis"; // ES Modules import
- * // const { KinesisClient, ListStreamsCommand } = require("@aws-sdk/client-kinesis"); // CommonJS import
- * const client = new KinesisClient(config);
- * const command = new ListStreamsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListStreamsCommandInput} for command's `input` shape.
- * @see {@link ListStreamsCommandOutput} for command's `response` shape.
- * @see {@link KinesisClientResolvedConfig | config} for command's `input` shape.
- *
- */
 class ListStreamsCommand extends smithy_client_1.Command {
-    // Start section: command_properties
-    // End section: command_properties
     constructor(input) {
-        // Start section: command_constructor
         super();
         this.input = input;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
         const stack = clientStack.concat(this.middlewareStack);

package/dist-cjs/commands/ListTagsForStreamCommand.js

@@ -5,36 +5,11 @@ const middleware_serde_1 = require("@aws-sdk/middleware-serde");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
 const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
-/**
- * <p>Lists the tags for the specified Kinesis data stream. This operation 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, ListTagsForStreamCommand } from "@aws-sdk/client-kinesis"; // ES Modules import
- * // const { KinesisClient, ListTagsForStreamCommand } = require("@aws-sdk/client-kinesis"); // CommonJS import
- * const client = new KinesisClient(config);
- * const command = new ListTagsForStreamCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsForStreamCommandInput} for command's `input` shape.
- * @see {@link ListTagsForStreamCommandOutput} for command's `response` shape.
- * @see {@link KinesisClientResolvedConfig | config} for command's `input` shape.
- *
- */
 class ListTagsForStreamCommand extends smithy_client_1.Command {
-    // Start section: command_properties
-    // End section: command_properties
     constructor(input) {
-        // Start section: command_constructor
         super();
         this.input = input;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
         const stack = clientStack.concat(this.middlewareStack);

package/dist-cjs/commands/MergeShardsCommand.js

@@ -5,70 +5,11 @@ const middleware_serde_1 = require("@aws-sdk/middleware-serde");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
 const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
-/**
- * <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
- *             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>
- *             <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
- *                 <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>DescribeStream</a> to check the state of the stream,
- *             which is returned in <code>StreamStatus</code>.</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>DescribeStream</a> 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>,
- *             or <a>SplitShard</a>, you receive a <code>LimitExceededException</code>. </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.
- * ```javascript
- * import { KinesisClient, MergeShardsCommand } from "@aws-sdk/client-kinesis"; // ES Modules import
- * // const { KinesisClient, MergeShardsCommand } = require("@aws-sdk/client-kinesis"); // CommonJS import
- * const client = new KinesisClient(config);
- * const command = new MergeShardsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link MergeShardsCommandInput} for command's `input` shape.
- * @see {@link MergeShardsCommandOutput} for command's `response` shape.
- * @see {@link KinesisClientResolvedConfig | config} for command's `input` shape.
- *
- */
 class MergeShardsCommand extends smithy_client_1.Command {
-    // Start section: command_properties
-    // End section: command_properties
     constructor(input) {
-        // Start section: command_constructor
         super();
         this.input = input;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
         const stack = clientStack.concat(this.middlewareStack);

package/dist-cjs/commands/PutRecordCommand.js

@@ -5,70 +5,11 @@ const middleware_serde_1 = require("@aws-sdk/middleware-serde");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
 const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
-/**
- * <p>Writes a single data record into an Amazon Kinesis data stream. Call
- *                 <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
- *             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,
- *             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.
- *             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 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>
- *             <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 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>
- *             <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
- *             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 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.
- * ```javascript
- * import { KinesisClient, PutRecordCommand } from "@aws-sdk/client-kinesis"; // ES Modules import
- * // const { KinesisClient, PutRecordCommand } = require("@aws-sdk/client-kinesis"); // CommonJS import
- * const client = new KinesisClient(config);
- * const command = new PutRecordCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutRecordCommandInput} for command's `input` shape.
- * @see {@link PutRecordCommandOutput} for command's `response` shape.
- * @see {@link KinesisClientResolvedConfig | config} for command's `input` shape.
- *
- */
 class PutRecordCommand extends smithy_client_1.Command {
-    // Start section: command_properties
-    // End section: command_properties
     constructor(input) {
-        // Start section: command_constructor
         super();
         this.input = input;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
         const stack = clientStack.concat(this.middlewareStack);

package/dist-cjs/commands/PutRecordsCommand.js

@@ -5,90 +5,11 @@ const middleware_serde_1 = require("@aws-sdk/middleware-serde");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
 const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
-/**
- * <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 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
- *             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,
- *             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
- *             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,
- *                 <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
- *                 <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 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
- *                 <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
- *                 <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>.
- *                 <code>ErrorMessage</code> provides more detailed information about the
- *                 <code>ProvisionedThroughputExceededException</code> exception including the account
- *             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>
- *             <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 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.
- * ```javascript
- * import { KinesisClient, PutRecordsCommand } from "@aws-sdk/client-kinesis"; // ES Modules import
- * // const { KinesisClient, PutRecordsCommand } = require("@aws-sdk/client-kinesis"); // CommonJS import
- * const client = new KinesisClient(config);
- * const command = new PutRecordsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutRecordsCommandInput} for command's `input` shape.
- * @see {@link PutRecordsCommandOutput} for command's `response` shape.
- * @see {@link KinesisClientResolvedConfig | config} for command's `input` shape.
- *
- */
 class PutRecordsCommand extends smithy_client_1.Command {
-    // Start section: command_properties
-    // End section: command_properties
     constructor(input) {
-        // Start section: command_constructor
         super();
         this.input = input;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
         const stack = clientStack.concat(this.middlewareStack);