@aws-sdk/client-kinesis 3.295.0 → 3.297.0

package/dist-types/Kinesis.d.ts

@@ -30,12 +30,14 @@ import { UpdateShardCountCommandInput, UpdateShardCountCommandOutput } from "./c
 import { UpdateStreamModeCommandInput, UpdateStreamModeCommandOutput } from "./commands/UpdateStreamModeCommand";
 import { KinesisClient } from "./KinesisClient";
 /**
+ * @public
  * <fullname>Amazon Kinesis Data Streams Service API Reference</fullname>
  *          <p>Amazon Kinesis Data Streams is a managed service that scales elastically for real-time
  *             processing of streaming big data.</p>
  */
 export declare class Kinesis extends KinesisClient {
     /**
+     * @public
      * <p>Adds or updates tags for the specified Kinesis data stream. You can assign up to 50
      *             tags to a data stream.</p>
      *          <note>
@@ -52,6 +54,7 @@ export declare class Kinesis extends KinesisClient {
     addTagsToStream(args: AddTagsToStreamCommandInput, cb: (err: any, data?: AddTagsToStreamCommandOutput) => void): void;
     addTagsToStream(args: AddTagsToStreamCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: AddTagsToStreamCommandOutput) => void): void;
     /**
+     * @public
      * <p>Creates a Kinesis data stream. A stream captures and transports data records that are
      *             continuously emitted from different data sources or <i>producers</i>.
      *             Scale-out within a stream is explicitly supported by means of shards, which are uniquely
@@ -101,6 +104,7 @@ export declare class Kinesis extends KinesisClient {
     createStream(args: CreateStreamCommandInput, cb: (err: any, data?: CreateStreamCommandOutput) => void): void;
     createStream(args: CreateStreamCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateStreamCommandOutput) => void): void;
     /**
+     * @public
      * <p>Decreases the Kinesis data stream's retention period, which is the length of time data
      *             records are accessible after they are added to the stream. The minimum value of a
      *             stream's retention period is 24 hours.</p>
@@ -116,6 +120,7 @@ export declare class Kinesis extends KinesisClient {
     decreaseStreamRetentionPeriod(args: DecreaseStreamRetentionPeriodCommandInput, cb: (err: any, data?: DecreaseStreamRetentionPeriodCommandOutput) => void): void;
     decreaseStreamRetentionPeriod(args: DecreaseStreamRetentionPeriodCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DecreaseStreamRetentionPeriodCommandOutput) => void): void;
     /**
+     * @public
      * <p>Deletes a Kinesis data stream and all its shards and data. You must shut down any
      *             applications that are operating on the stream before you delete the stream. If an
      *             application attempts to operate on a deleted stream, it receives the exception
@@ -144,6 +149,7 @@ export declare class Kinesis extends KinesisClient {
     deleteStream(args: DeleteStreamCommandInput, cb: (err: any, data?: DeleteStreamCommandOutput) => void): void;
     deleteStream(args: DeleteStreamCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteStreamCommandOutput) => void): void;
     /**
+     * @public
      * <p>To deregister a consumer, provide its ARN. Alternatively, you can provide the ARN of
      *             the data stream and the name you gave the consumer when you registered it. You may also
      *             provide all three parameters, as long as they don't conflict with each other. If you
@@ -157,6 +163,7 @@ export declare class Kinesis extends KinesisClient {
     deregisterStreamConsumer(args: DeregisterStreamConsumerCommandInput, cb: (err: any, data?: DeregisterStreamConsumerCommandOutput) => void): void;
     deregisterStreamConsumer(args: DeregisterStreamConsumerCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeregisterStreamConsumerCommandOutput) => void): void;
     /**
+     * @public
      * <p>Describes the shard limits and usage for the account.</p>
      *          <p>If you update your account limits, the old limits might be returned for a few
      *             minutes.</p>
@@ -166,6 +173,7 @@ export declare class Kinesis extends KinesisClient {
     describeLimits(args: DescribeLimitsCommandInput, cb: (err: any, data?: DescribeLimitsCommandOutput) => void): void;
     describeLimits(args: DescribeLimitsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeLimitsCommandOutput) => void): void;
     /**
+     * @public
      * <p>Describes the specified Kinesis data stream.</p>
      *          <note>
      *             <p>This API has been revised. It's highly recommended that you use the <a>DescribeStreamSummary</a> API to get a summarized description of the
@@ -195,6 +203,7 @@ export declare class Kinesis extends KinesisClient {
     describeStream(args: DescribeStreamCommandInput, cb: (err: any, data?: DescribeStreamCommandOutput) => void): void;
     describeStream(args: DescribeStreamCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeStreamCommandOutput) => void): void;
     /**
+     * @public
      * <p>To get the description of a registered consumer, provide the ARN of the consumer.
      *             Alternatively, you can provide the ARN of the data stream and the name you gave the
      *             consumer when you registered it. You may also provide all three parameters, as long as
@@ -208,6 +217,7 @@ export declare class Kinesis extends KinesisClient {
     describeStreamConsumer(args: DescribeStreamConsumerCommandInput, cb: (err: any, data?: DescribeStreamConsumerCommandOutput) => void): void;
     describeStreamConsumer(args: DescribeStreamConsumerCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeStreamConsumerCommandOutput) => void): void;
     /**
+     * @public
      * <p>Provides a summarized description of the specified Kinesis data stream without the
      *             shard list.</p>
      *          <note>
@@ -225,6 +235,7 @@ export declare class Kinesis extends KinesisClient {
     describeStreamSummary(args: DescribeStreamSummaryCommandInput, cb: (err: any, data?: DescribeStreamSummaryCommandOutput) => void): void;
     describeStreamSummary(args: DescribeStreamSummaryCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeStreamSummaryCommandOutput) => void): void;
     /**
+     * @public
      * <p>Disables enhanced monitoring.</p>
      *          <note>
      *             <p>When invoking this API, it is recommended you use the <code>StreamARN</code> input
@@ -235,6 +246,7 @@ export declare class Kinesis extends KinesisClient {
     disableEnhancedMonitoring(args: DisableEnhancedMonitoringCommandInput, cb: (err: any, data?: DisableEnhancedMonitoringCommandOutput) => void): void;
     disableEnhancedMonitoring(args: DisableEnhancedMonitoringCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DisableEnhancedMonitoringCommandOutput) => void): void;
     /**
+     * @public
      * <p>Enables enhanced Kinesis data stream monitoring for shard-level metrics.</p>
      *          <note>
      *             <p>When invoking this API, it is recommended you use the <code>StreamARN</code> input
@@ -245,6 +257,7 @@ export declare class Kinesis extends KinesisClient {
     enableEnhancedMonitoring(args: EnableEnhancedMonitoringCommandInput, cb: (err: any, data?: EnableEnhancedMonitoringCommandOutput) => void): void;
     enableEnhancedMonitoring(args: EnableEnhancedMonitoringCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: EnableEnhancedMonitoringCommandOutput) => void): void;
     /**
+     * @public
      * <p>Gets data records from a Kinesis data stream's shard.</p>
      *          <note>
      *             <p>When invoking this API, it is recommended you use the <code>StreamARN</code> input
@@ -302,6 +315,7 @@ export declare class Kinesis extends KinesisClient {
     getRecords(args: GetRecordsCommandInput, cb: (err: any, data?: GetRecordsCommandOutput) => void): void;
     getRecords(args: GetRecordsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetRecordsCommandOutput) => void): void;
     /**
+     * @public
      * <p>Gets an Amazon Kinesis shard iterator. A shard iterator expires 5 minutes after it is
      *             returned to the requester.</p>
      *          <note>
@@ -345,6 +359,7 @@ export declare class Kinesis extends KinesisClient {
     getShardIterator(args: GetShardIteratorCommandInput, cb: (err: any, data?: GetShardIteratorCommandOutput) => void): void;
     getShardIterator(args: GetShardIteratorCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetShardIteratorCommandOutput) => void): void;
     /**
+     * @public
      * <p>Increases the Kinesis data stream's retention period, which is the length of time data
      *             records are accessible after they are added to the stream. The maximum value of a
      *             stream's retention period is 8760 hours (365 days).</p>
@@ -363,6 +378,7 @@ export declare class Kinesis extends KinesisClient {
     increaseStreamRetentionPeriod(args: IncreaseStreamRetentionPeriodCommandInput, cb: (err: any, data?: IncreaseStreamRetentionPeriodCommandOutput) => void): void;
     increaseStreamRetentionPeriod(args: IncreaseStreamRetentionPeriodCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: IncreaseStreamRetentionPeriodCommandOutput) => void): void;
     /**
+     * @public
      * <p>Lists the shards in a stream and provides information about each shard. This operation
      *             has a limit of 1000 transactions per second per data stream.</p>
      *          <note>
@@ -383,6 +399,7 @@ export declare class Kinesis extends KinesisClient {
     listShards(args: ListShardsCommandInput, cb: (err: any, data?: ListShardsCommandOutput) => void): void;
     listShards(args: ListShardsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListShardsCommandOutput) => void): void;
     /**
+     * @public
      * <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>
@@ -391,6 +408,7 @@ export declare class Kinesis extends KinesisClient {
     listStreamConsumers(args: ListStreamConsumersCommandInput, cb: (err: any, data?: ListStreamConsumersCommandOutput) => void): void;
     listStreamConsumers(args: ListStreamConsumersCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListStreamConsumersCommandOutput) => void): void;
     /**
+     * @public
      * <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
@@ -412,6 +430,7 @@ export declare class Kinesis extends KinesisClient {
     listStreams(args: ListStreamsCommandInput, cb: (err: any, data?: ListStreamsCommandOutput) => void): void;
     listStreams(args: ListStreamsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListStreamsCommandOutput) => void): void;
     /**
+     * @public
      * <p>Lists the tags for the specified Kinesis data stream. This operation has a limit of
      *             five transactions per second per account.</p>
      *          <note>
@@ -423,6 +442,7 @@ export declare class Kinesis extends KinesisClient {
     listTagsForStream(args: ListTagsForStreamCommandInput, cb: (err: any, data?: ListTagsForStreamCommandOutput) => void): void;
     listTagsForStream(args: ListTagsForStreamCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTagsForStreamCommandOutput) => void): void;
     /**
+     * @public
      * <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. This API is only
      *             supported for the data streams with the provisioned capacity mode. Two shards are
@@ -469,6 +489,7 @@ export declare class Kinesis extends KinesisClient {
     mergeShards(args: MergeShardsCommandInput, cb: (err: any, data?: MergeShardsCommandOutput) => void): void;
     mergeShards(args: MergeShardsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: MergeShardsCommandOutput) => void): void;
     /**
+     * @public
      * <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
@@ -514,6 +535,7 @@ export declare class Kinesis extends KinesisClient {
     putRecord(args: PutRecordCommandInput, cb: (err: any, data?: PutRecordCommandOutput) => void): void;
     putRecord(args: PutRecordCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutRecordCommandOutput) => void): void;
     /**
+     * @public
      * <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>
@@ -579,6 +601,7 @@ export declare class Kinesis extends KinesisClient {
     putRecords(args: PutRecordsCommandInput, cb: (err: any, data?: PutRecordsCommandOutput) => void): void;
     putRecords(args: PutRecordsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutRecordsCommandOutput) => void): void;
     /**
+     * @public
      * <p>Registers a consumer with a Kinesis data stream. When you use this operation, the
      *             consumer you register can then call <a>SubscribeToShard</a> to receive data
      *             from the stream using enhanced fan-out, at a rate of up to 2 MiB per second for every
@@ -598,6 +621,7 @@ export declare class Kinesis extends KinesisClient {
     registerStreamConsumer(args: RegisterStreamConsumerCommandInput, cb: (err: any, data?: RegisterStreamConsumerCommandOutput) => void): void;
     registerStreamConsumer(args: RegisterStreamConsumerCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: RegisterStreamConsumerCommandOutput) => void): void;
     /**
+     * @public
      * <p>Removes tags from the specified Kinesis data stream. Removed tags are deleted and
      *             cannot be recovered after this operation successfully completes.</p>
      *          <note>
@@ -613,6 +637,7 @@ export declare class Kinesis extends KinesisClient {
     removeTagsFromStream(args: RemoveTagsFromStreamCommandInput, cb: (err: any, data?: RemoveTagsFromStreamCommandOutput) => void): void;
     removeTagsFromStream(args: RemoveTagsFromStreamCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: RemoveTagsFromStreamCommandOutput) => void): void;
     /**
+     * @public
      * <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
@@ -663,6 +688,7 @@ export declare class Kinesis extends KinesisClient {
     splitShard(args: SplitShardCommandInput, cb: (err: any, data?: SplitShardCommandOutput) => void): void;
     splitShard(args: SplitShardCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: SplitShardCommandOutput) => void): void;
     /**
+     * @public
      * <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
@@ -688,6 +714,7 @@ export declare class Kinesis extends KinesisClient {
     startStreamEncryption(args: StartStreamEncryptionCommandInput, cb: (err: any, data?: StartStreamEncryptionCommandOutput) => void): void;
     startStreamEncryption(args: StartStreamEncryptionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartStreamEncryptionCommandOutput) => void): void;
     /**
+     * @public
      * <p>Disables server-side encryption for a specified stream. </p>
      *          <note>
      *             <p>When invoking this API, it is recommended you use the <code>StreamARN</code> input
@@ -712,6 +739,7 @@ export declare class Kinesis extends KinesisClient {
     stopStreamEncryption(args: StopStreamEncryptionCommandInput, cb: (err: any, data?: StopStreamEncryptionCommandOutput) => void): void;
     stopStreamEncryption(args: StopStreamEncryptionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StopStreamEncryptionCommandOutput) => void): void;
     /**
+     * @public
      * <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,
@@ -740,6 +768,7 @@ export declare class Kinesis extends KinesisClient {
     subscribeToShard(args: SubscribeToShardCommandInput, cb: (err: any, data?: SubscribeToShardCommandOutput) => void): void;
     subscribeToShard(args: SubscribeToShardCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: SubscribeToShardCommandOutput) => void): void;
     /**
+     * @public
      * <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>
@@ -793,6 +822,7 @@ export declare class Kinesis extends KinesisClient {
     updateShardCount(args: UpdateShardCountCommandInput, cb: (err: any, data?: UpdateShardCountCommandOutput) => void): void;
     updateShardCount(args: UpdateShardCountCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateShardCountCommandOutput) => void): void;
     /**
+     * @public
      * <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.

package/dist-types/KinesisClient.d.ts

@@ -38,15 +38,24 @@ import { SubscribeToShardCommandInput, SubscribeToShardCommandOutput } from "./c
 import { UpdateShardCountCommandInput, UpdateShardCountCommandOutput } from "./commands/UpdateShardCountCommand";
 import { UpdateStreamModeCommandInput, UpdateStreamModeCommandOutput } from "./commands/UpdateStreamModeCommand";
 import { ClientInputEndpointParameters, ClientResolvedEndpointParameters, EndpointParameters } from "./endpoint/EndpointParameters";
+/**
+ * @public
+ */
 export type ServiceInputTypes = AddTagsToStreamCommandInput | CreateStreamCommandInput | DecreaseStreamRetentionPeriodCommandInput | DeleteStreamCommandInput | DeregisterStreamConsumerCommandInput | DescribeLimitsCommandInput | DescribeStreamCommandInput | DescribeStreamConsumerCommandInput | DescribeStreamSummaryCommandInput | DisableEnhancedMonitoringCommandInput | EnableEnhancedMonitoringCommandInput | GetRecordsCommandInput | GetShardIteratorCommandInput | IncreaseStreamRetentionPeriodCommandInput | ListShardsCommandInput | ListStreamConsumersCommandInput | ListStreamsCommandInput | ListTagsForStreamCommandInput | MergeShardsCommandInput | PutRecordCommandInput | PutRecordsCommandInput | RegisterStreamConsumerCommandInput | RemoveTagsFromStreamCommandInput | SplitShardCommandInput | StartStreamEncryptionCommandInput | StopStreamEncryptionCommandInput | SubscribeToShardCommandInput | UpdateShardCountCommandInput | UpdateStreamModeCommandInput;
+/**
+ * @public
+ */
 export type ServiceOutputTypes = AddTagsToStreamCommandOutput | CreateStreamCommandOutput | DecreaseStreamRetentionPeriodCommandOutput | DeleteStreamCommandOutput | DeregisterStreamConsumerCommandOutput | DescribeLimitsCommandOutput | DescribeStreamCommandOutput | DescribeStreamConsumerCommandOutput | DescribeStreamSummaryCommandOutput | DisableEnhancedMonitoringCommandOutput | EnableEnhancedMonitoringCommandOutput | GetRecordsCommandOutput | GetShardIteratorCommandOutput | IncreaseStreamRetentionPeriodCommandOutput | ListShardsCommandOutput | ListStreamConsumersCommandOutput | ListStreamsCommandOutput | ListTagsForStreamCommandOutput | MergeShardsCommandOutput | PutRecordCommandOutput | PutRecordsCommandOutput | RegisterStreamConsumerCommandOutput | RemoveTagsFromStreamCommandOutput | SplitShardCommandOutput | StartStreamEncryptionCommandOutput | StopStreamEncryptionCommandOutput | SubscribeToShardCommandOutput | UpdateShardCountCommandOutput | UpdateStreamModeCommandOutput;
+/**
+ * @public
+ */
 export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
     /**
      * The HTTP handler to use. Fetch in browser and Https in Nodejs.
      */
     requestHandler?: __HttpHandler;
     /**
-     * A constructor for a class implementing the {@link __Checksum} interface
+     * A constructor for a class implementing the {@link @aws-sdk/types#ChecksumConstructor} interface
      * that computes the SHA-256 HMAC or checksum of a string or binary buffer.
      * @internal
      */
@@ -140,23 +149,34 @@ export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__
      */
     eventStreamSerdeProvider?: __EventStreamSerdeProvider;
     /**
-     * The {@link __DefaultsMode} that will be used to determine how certain default configuration options are resolved in the SDK.
+     * The {@link @aws-sdk/smithy-client#DefaultsMode} that will be used to determine how certain default configuration options are resolved in the SDK.
      */
     defaultsMode?: __DefaultsMode | __Provider<__DefaultsMode>;
 }
+/**
+ * @public
+ */
 type KinesisClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointInputConfig<EndpointParameters> & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig & EventStreamSerdeInputConfig & ClientInputEndpointParameters;
 /**
- * The configuration interface of KinesisClient class constructor that set the region, credentials and other options.
+ * @public
+ *
+ *  The configuration interface of KinesisClient class constructor that set the region, credentials and other options.
  */
 export interface KinesisClientConfig extends KinesisClientConfigType {
 }
+/**
+ * @public
+ */
 type KinesisClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RegionResolvedConfig & EndpointResolvedConfig<EndpointParameters> & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig & EventStreamSerdeResolvedConfig & ClientResolvedEndpointParameters;
 /**
- * The resolved configuration interface of KinesisClient class. This is resolved and normalized from the {@link KinesisClientConfig | constructor configuration interface}.
+ * @public
+ *
+ *  The resolved configuration interface of KinesisClient class. This is resolved and normalized from the {@link KinesisClientConfig | constructor configuration interface}.
  */
 export interface KinesisClientResolvedConfig extends KinesisClientResolvedConfigType {
 }
 /**
+ * @public
  * <fullname>Amazon Kinesis Data Streams Service API Reference</fullname>
  *          <p>Amazon Kinesis Data Streams is a managed service that scales elastically for real-time
  *             processing of streaming big data.</p>

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { KinesisClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KinesisClient";
 import { AddTagsToStreamInput } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link AddTagsToStreamCommand}.
  */
 export interface AddTagsToStreamCommandInput extends AddTagsToStreamInput {
 }
 /**
+ * @public
+ *
  * The output of {@link AddTagsToStreamCommand}.
  */
 export interface AddTagsToStreamCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Adds or updates tags for the specified Kinesis data stream. You can assign up to 50
  *             tags to a data stream.</p>
  *          <note>
@@ -35,6 +40,8 @@ export interface AddTagsToStreamCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param AddTagsToStreamCommandInput - {@link AddTagsToStreamCommandInput}
+ * @returns {@link AddTagsToStreamCommandOutput}
  * @see {@link AddTagsToStreamCommandInput} for command's `input` shape.
  * @see {@link AddTagsToStreamCommandOutput} for command's `response` shape.
  * @see {@link KinesisClientResolvedConfig | config} for KinesisClient's `config` shape.
@@ -64,11 +71,20 @@ export interface AddTagsToStreamCommandOutput extends __MetadataBearer {
 export declare class AddTagsToStreamCommand extends $Command<AddTagsToStreamCommandInput, AddTagsToStreamCommandOutput, KinesisClientResolvedConfig> {
     readonly input: AddTagsToStreamCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AddTagsToStreamCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AddTagsToStreamCommandInput, AddTagsToStreamCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { KinesisClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KinesisClient";
 import { CreateStreamInput } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateStreamCommand}.
  */
 export interface CreateStreamCommandInput extends CreateStreamInput {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateStreamCommand}.
  */
 export interface CreateStreamCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a Kinesis data stream. A stream captures and transports data records that are
  *             continuously emitted from different data sources or <i>producers</i>.
  *             Scale-out within a stream is explicitly supported by means of shards, which are uniquely
@@ -68,6 +73,8 @@ export interface CreateStreamCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateStreamCommandInput - {@link CreateStreamCommandInput}
+ * @returns {@link CreateStreamCommandOutput}
  * @see {@link CreateStreamCommandInput} for command's `input` shape.
  * @see {@link CreateStreamCommandOutput} for command's `response` shape.
  * @see {@link KinesisClientResolvedConfig | config} for KinesisClient's `config` shape.
@@ -89,11 +96,20 @@ export interface CreateStreamCommandOutput extends __MetadataBearer {
 export declare class CreateStreamCommand extends $Command<CreateStreamCommandInput, CreateStreamCommandOutput, KinesisClientResolvedConfig> {
     readonly input: CreateStreamCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateStreamCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateStreamCommandInput, CreateStreamCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { KinesisClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KinesisClient";
 import { DecreaseStreamRetentionPeriodInput } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DecreaseStreamRetentionPeriodCommand}.
  */
 export interface DecreaseStreamRetentionPeriodCommandInput extends DecreaseStreamRetentionPeriodInput {
 }
 /**
+ * @public
+ *
  * The output of {@link DecreaseStreamRetentionPeriodCommand}.
  */
 export interface DecreaseStreamRetentionPeriodCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Decreases the Kinesis data stream's retention period, which is the length of time data
  *             records are accessible after they are added to the stream. The minimum value of a
  *             stream's retention period is 24 hours.</p>
@@ -34,6 +39,8 @@ export interface DecreaseStreamRetentionPeriodCommandOutput extends __MetadataBe
  * const response = await client.send(command);
  * ```
  *
+ * @param DecreaseStreamRetentionPeriodCommandInput - {@link DecreaseStreamRetentionPeriodCommandInput}
+ * @returns {@link DecreaseStreamRetentionPeriodCommandOutput}
  * @see {@link DecreaseStreamRetentionPeriodCommandInput} for command's `input` shape.
  * @see {@link DecreaseStreamRetentionPeriodCommandOutput} for command's `response` shape.
  * @see {@link KinesisClientResolvedConfig | config} for KinesisClient's `config` shape.
@@ -63,11 +70,20 @@ export interface DecreaseStreamRetentionPeriodCommandOutput extends __MetadataBe
 export declare class DecreaseStreamRetentionPeriodCommand extends $Command<DecreaseStreamRetentionPeriodCommandInput, DecreaseStreamRetentionPeriodCommandOutput, KinesisClientResolvedConfig> {
     readonly input: DecreaseStreamRetentionPeriodCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DecreaseStreamRetentionPeriodCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DecreaseStreamRetentionPeriodCommandInput, DecreaseStreamRetentionPeriodCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { KinesisClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KinesisClient";
 import { DeleteStreamInput } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteStreamCommand}.
  */
 export interface DeleteStreamCommandInput extends DeleteStreamInput {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteStreamCommand}.
  */
 export interface DeleteStreamCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes a Kinesis data stream and all its shards and data. You must shut down any
  *             applications that are operating on the stream before you delete the stream. If an
  *             application attempts to operate on a deleted stream, it receives the exception
@@ -47,6 +52,8 @@ export interface DeleteStreamCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteStreamCommandInput - {@link DeleteStreamCommandInput}
+ * @returns {@link DeleteStreamCommandOutput}
  * @see {@link DeleteStreamCommandInput} for command's `input` shape.
  * @see {@link DeleteStreamCommandOutput} for command's `response` shape.
  * @see {@link KinesisClientResolvedConfig | config} for KinesisClient's `config` shape.
@@ -76,11 +83,20 @@ export interface DeleteStreamCommandOutput extends __MetadataBearer {
 export declare class DeleteStreamCommand extends $Command<DeleteStreamCommandInput, DeleteStreamCommandOutput, KinesisClientResolvedConfig> {
     readonly input: DeleteStreamCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteStreamCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteStreamCommandInput, DeleteStreamCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { KinesisClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KinesisClient";
 import { DeregisterStreamConsumerInput } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeregisterStreamConsumerCommand}.
  */
 export interface DeregisterStreamConsumerCommandInput extends DeregisterStreamConsumerInput {
 }
 /**
+ * @public
+ *
  * The output of {@link DeregisterStreamConsumerCommand}.
  */
 export interface DeregisterStreamConsumerCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>To deregister a consumer, provide its ARN. Alternatively, you can provide the ARN of
  *             the data stream and the name you gave the consumer when you registered it. You may also
  *             provide all three parameters, as long as they don't conflict with each other. If you
@@ -32,6 +37,8 @@ export interface DeregisterStreamConsumerCommandOutput extends __MetadataBearer
  * const response = await client.send(command);
  * ```
  *
+ * @param DeregisterStreamConsumerCommandInput - {@link DeregisterStreamConsumerCommandInput}
+ * @returns {@link DeregisterStreamConsumerCommandOutput}
  * @see {@link DeregisterStreamConsumerCommandInput} for command's `input` shape.
  * @see {@link DeregisterStreamConsumerCommandOutput} for command's `response` shape.
  * @see {@link KinesisClientResolvedConfig | config} for KinesisClient's `config` shape.
@@ -53,11 +60,20 @@ export interface DeregisterStreamConsumerCommandOutput extends __MetadataBearer
 export declare class DeregisterStreamConsumerCommand extends $Command<DeregisterStreamConsumerCommandInput, DeregisterStreamConsumerCommandOutput, KinesisClientResolvedConfig> {
     readonly input: DeregisterStreamConsumerCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeregisterStreamConsumerCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeregisterStreamConsumerCommandInput, DeregisterStreamConsumerCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { KinesisClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../KinesisClient";
 import { DescribeLimitsInput, DescribeLimitsOutput } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DescribeLimitsCommand}.
  */
 export interface DescribeLimitsCommandInput extends DescribeLimitsInput {
 }
 /**
+ * @public
+ *
  * The output of {@link DescribeLimitsCommand}.
  */
 export interface DescribeLimitsCommandOutput extends DescribeLimitsOutput, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Describes the shard limits and usage for the account.</p>
  *          <p>If you update your account limits, the old limits might be returned for a few
  *             minutes.</p>
@@ -28,6 +33,8 @@ export interface DescribeLimitsCommandOutput extends DescribeLimitsOutput, __Met
  * const response = await client.send(command);
  * ```
  *
+ * @param DescribeLimitsCommandInput - {@link DescribeLimitsCommandInput}
+ * @returns {@link DescribeLimitsCommandOutput}
  * @see {@link DescribeLimitsCommandInput} for command's `input` shape.
  * @see {@link DescribeLimitsCommandOutput} for command's `response` shape.
  * @see {@link KinesisClientResolvedConfig | config} for KinesisClient's `config` shape.
@@ -41,11 +48,20 @@ export interface DescribeLimitsCommandOutput extends DescribeLimitsOutput, __Met
 export declare class DescribeLimitsCommand extends $Command<DescribeLimitsCommandInput, DescribeLimitsCommandOutput, KinesisClientResolvedConfig> {
     readonly input: DescribeLimitsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DescribeLimitsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeLimitsCommandInput, DescribeLimitsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }