@aws-sdk/client-firehose 3.36.0 → 3.39.0

package/CHANGELOG.md

@@ -3,6 +3,48 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.39.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.38.0...v3.39.0) (2021-10-29)
+
+**Note:** Version bump only for package @aws-sdk/client-firehose
+
+
+
+
+
+# [3.38.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.37.0...v3.38.0) (2021-10-22)
+
+
+### Features
+
+* **client-documentation-generator:** rename package ([#2916](https://github.com/aws/aws-sdk-js-v3/issues/2916)) ([1a80bfd](https://github.com/aws/aws-sdk-js-v3/commit/1a80bfd2dfc583001ddb4a21b6432eaaad699aa7))
+* **clients:** export folder from index.ts ([#2912](https://github.com/aws/aws-sdk-js-v3/issues/2912)) ([183b46d](https://github.com/aws/aws-sdk-js-v3/commit/183b46dde7f5613128038bf1c076f3c0b693203b))
+
+
+
+
+
+# [3.37.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.36.1...v3.37.0) (2021-10-15)
+
+
+### Features
+
+* **clients:** update clients as of 10/15/2021 ([#2902](https://github.com/aws/aws-sdk-js-v3/issues/2902)) ([2730b54](https://github.com/aws/aws-sdk-js-v3/commit/2730b5424377944a5a2ad5e1ad7d3ca4135dae1c))
+
+
+
+
+
+## [3.36.1](https://github.com/aws/aws-sdk-js-v3/compare/v3.36.0...v3.36.1) (2021-10-12)
+
+
+### Bug Fixes
+
+* **clients:** emitDeclarationOnly in tsconfig.types.json ([#2893](https://github.com/aws/aws-sdk-js-v3/issues/2893)) ([6dc3d56](https://github.com/aws/aws-sdk-js-v3/commit/6dc3d56c20809c90cbdc4dd48627eeebc64af99d))
+
+
+
+
+
 # [3.36.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.35.0...v3.36.0) (2021-10-08)
 
 

package/dist-cjs/Firehose.js

@@ -14,12 +14,6 @@ const TagDeliveryStreamCommand_1 = require("./commands/TagDeliveryStreamCommand"
 const UntagDeliveryStreamCommand_1 = require("./commands/UntagDeliveryStreamCommand");
 const UpdateDestinationCommand_1 = require("./commands/UpdateDestinationCommand");
 const FirehoseClient_1 = require("./FirehoseClient");
-/**
- * <fullname>Amazon Kinesis Data Firehose API Reference</fullname>
- *          <p>Amazon Kinesis Data Firehose is a fully managed service that delivers real-time
- *          streaming data to destinations such as Amazon Simple Storage Service (Amazon S3), Amazon
- *          Elasticsearch Service (Amazon ES), Amazon Redshift, and Splunk.</p>
- */
 class Firehose extends FirehoseClient_1.FirehoseClient {
     createDeliveryStream(args, optionsOrCb, cb) {
         const command = new CreateDeliveryStreamCommand_1.CreateDeliveryStreamCommand(args);

package/dist-cjs/FirehoseClient.js

@@ -10,12 +10,6 @@ const middleware_signing_1 = require("@aws-sdk/middleware-signing");
 const middleware_user_agent_1 = require("@aws-sdk/middleware-user-agent");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const runtimeConfig_1 = require("./runtimeConfig");
-/**
- * <fullname>Amazon Kinesis Data Firehose API Reference</fullname>
- *          <p>Amazon Kinesis Data Firehose is a fully managed service that delivers real-time
- *          streaming data to destinations such as Amazon Simple Storage Service (Amazon S3), Amazon
- *          Elasticsearch Service (Amazon ES), Amazon Redshift, and Splunk.</p>
- */
 class FirehoseClient extends smithy_client_1.Client {
     constructor(configuration) {
         const _config_0 = runtimeConfig_1.getRuntimeConfig(configuration);
@@ -34,11 +28,6 @@ class FirehoseClient extends smithy_client_1.Client {
         this.middlewareStack.use(middleware_signing_1.getAwsAuthPlugin(this.config));
         this.middlewareStack.use(middleware_user_agent_1.getUserAgentPlugin(this.config));
     }
-    /**
-     * Destroy underlying resources, like sockets. It's usually not necessary to do this.
-     * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
-     * Otherwise, sockets might stay open for quite a long time before the server terminates them.
-     */
     destroy() {
         super.destroy();
     }

package/dist-cjs/commands/CreateDeliveryStreamCommand.js

@@ -5,103 +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>Creates a Kinesis Data Firehose delivery stream.</p>
- *
- *          <p>By default, you can create up to 50 delivery streams per AWS Region.</p>
- *          <p>This is an asynchronous operation that immediately returns. The initial status of the
- *          delivery stream is <code>CREATING</code>. After the delivery stream is created, its status
- *          is <code>ACTIVE</code> and it now accepts data. If the delivery stream creation fails, the
- *          status transitions to <code>CREATING_FAILED</code>. Attempts to send data to a delivery
- *          stream that is not in the <code>ACTIVE</code> state cause an exception. To check the state
- *          of a delivery stream, use <a>DescribeDeliveryStream</a>.</p>
- *          <p>If the status of a delivery stream is <code>CREATING_FAILED</code>, this status
- *          doesn't change, and you can't invoke <code>CreateDeliveryStream</code> again on it.
- *          However, you can invoke the <a>DeleteDeliveryStream</a> operation to delete
- *          it.</p>
- *          <p>A Kinesis Data Firehose delivery stream can be configured to receive records directly
- *          from providers using <a>PutRecord</a> or <a>PutRecordBatch</a>, or it
- *          can be configured to use an existing Kinesis stream as its source. To specify a Kinesis
- *          data stream as input, set the <code>DeliveryStreamType</code> parameter to
- *             <code>KinesisStreamAsSource</code>, and provide the Kinesis stream Amazon Resource Name
- *          (ARN) and role ARN in the <code>KinesisStreamSourceConfiguration</code>
- *          parameter.</p>
- *          <p>To create a delivery stream with server-side encryption (SSE) enabled, include <a>DeliveryStreamEncryptionConfigurationInput</a> in your request. This is
- *          optional. You can also invoke <a>StartDeliveryStreamEncryption</a> to turn on
- *          SSE for an existing delivery stream that doesn't have SSE enabled.</p>
- *          <p>A delivery stream is configured with a single destination: Amazon S3, Amazon ES,
- *          Amazon Redshift, or Splunk. You must specify only one of the following destination
- *          configuration parameters: <code>ExtendedS3DestinationConfiguration</code>,
- *             <code>S3DestinationConfiguration</code>,
- *             <code>ElasticsearchDestinationConfiguration</code>,
- *             <code>RedshiftDestinationConfiguration</code>, or
- *             <code>SplunkDestinationConfiguration</code>.</p>
- *          <p>When you specify <code>S3DestinationConfiguration</code>, you can also provide the
- *          following optional values: BufferingHints, <code>EncryptionConfiguration</code>, and
- *             <code>CompressionFormat</code>. By default, if no <code>BufferingHints</code> value is
- *          provided, Kinesis Data Firehose buffers data up to 5 MB or for 5 minutes, whichever
- *          condition is satisfied first. <code>BufferingHints</code> is a hint, so there are some
- *          cases where the service cannot adhere to these conditions strictly. For example, record
- *          boundaries might be such that the size is a little over or under the configured buffering
- *          size. By default, no encryption is performed. We strongly recommend that you enable
- *          encryption to ensure secure data storage in Amazon S3.</p>
- *
- *          <p>A few notes about Amazon Redshift as a destination:</p>
- *          <ul>
- *             <li>
- *                <p>An Amazon Redshift destination requires an S3 bucket as intermediate location.
- *                Kinesis Data Firehose first delivers data to Amazon S3 and then uses
- *                   <code>COPY</code> syntax to load data into an Amazon Redshift table. This is
- *                specified in the <code>RedshiftDestinationConfiguration.S3Configuration</code>
- *                parameter.</p>
- *
- *             </li>
- *             <li>
- *                <p>The compression formats <code>SNAPPY</code> or <code>ZIP</code> cannot be
- *                specified in <code>RedshiftDestinationConfiguration.S3Configuration</code> because
- *                the Amazon Redshift <code>COPY</code> operation that reads from the S3 bucket doesn't
- *                support these compression formats.</p>
- *             </li>
- *             <li>
- *                <p>We strongly recommend that you use the user name and password you provide
- *                exclusively with Kinesis Data Firehose, and that the permissions for the account are
- *                restricted for Amazon Redshift <code>INSERT</code> permissions.</p>
- *
- *             </li>
- *          </ul>
- *          <p>Kinesis Data Firehose assumes the IAM role that is configured as part of the
- *          destination. The role should allow the Kinesis Data Firehose principal to assume the role,
- *          and the role should have permissions that allow the service to deliver the data. For more
- *          information, see <a href="https://docs.aws.amazon.com/firehose/latest/dev/controlling-access.html#using-iam-s3">Grant Kinesis Data
- *             Firehose Access to an Amazon S3 Destination</a> in the <i>Amazon Kinesis Data
- *             Firehose Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { FirehoseClient, CreateDeliveryStreamCommand } from "@aws-sdk/client-firehose"; // ES Modules import
- * // const { FirehoseClient, CreateDeliveryStreamCommand } = require("@aws-sdk/client-firehose"); // CommonJS import
- * const client = new FirehoseClient(config);
- * const command = new CreateDeliveryStreamCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateDeliveryStreamCommandInput} for command's `input` shape.
- * @see {@link CreateDeliveryStreamCommandOutput} for command's `response` shape.
- * @see {@link FirehoseClientResolvedConfig | config} for command's `input` shape.
- *
- */
 class CreateDeliveryStreamCommand 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/DeleteDeliveryStreamCommand.js

@@ -5,44 +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>Deletes a delivery stream and its data.</p>
- *          <p>To check the state of a delivery stream, use <a>DescribeDeliveryStream</a>. You can delete a delivery stream only if it is in one of the following states:
- *             <code>ACTIVE</code>, <code>DELETING</code>, <code>CREATING_FAILED</code>, or
- *             <code>DELETING_FAILED</code>. You can't delete a delivery stream that is in the
- *             <code>CREATING</code> state. While the deletion request is in process, the delivery
- *          stream is in the <code>DELETING</code> state.</p>
- *          <p>While the delivery stream is in the <code>DELETING</code> state, the service might
- *          continue to accept records, but it doesn't make any guarantees with respect to delivering
- *          the data. Therefore, as a best practice, first stop any applications that are sending
- *          records before you delete a delivery stream.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { FirehoseClient, DeleteDeliveryStreamCommand } from "@aws-sdk/client-firehose"; // ES Modules import
- * // const { FirehoseClient, DeleteDeliveryStreamCommand } = require("@aws-sdk/client-firehose"); // CommonJS import
- * const client = new FirehoseClient(config);
- * const command = new DeleteDeliveryStreamCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDeliveryStreamCommandInput} for command's `input` shape.
- * @see {@link DeleteDeliveryStreamCommandOutput} for command's `response` shape.
- * @see {@link FirehoseClientResolvedConfig | config} for command's `input` shape.
- *
- */
 class DeleteDeliveryStreamCommand 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/DescribeDeliveryStreamCommand.js

@@ -5,41 +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>Describes the specified delivery stream and its status. For example, after your
- *          delivery stream is created, call <code>DescribeDeliveryStream</code> to see whether the
- *          delivery stream is <code>ACTIVE</code> and therefore ready for data to be sent to it. </p>
- *          <p>If the status of a delivery stream is <code>CREATING_FAILED</code>, this status
- *          doesn't change, and you can't invoke <a>CreateDeliveryStream</a> again on it.
- *          However, you can invoke the <a>DeleteDeliveryStream</a> operation to delete it.
- *          If the status is <code>DELETING_FAILED</code>, you can force deletion by invoking <a>DeleteDeliveryStream</a> again but with <a>DeleteDeliveryStreamInput$AllowForceDelete</a> set to true.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { FirehoseClient, DescribeDeliveryStreamCommand } from "@aws-sdk/client-firehose"; // ES Modules import
- * // const { FirehoseClient, DescribeDeliveryStreamCommand } = require("@aws-sdk/client-firehose"); // CommonJS import
- * const client = new FirehoseClient(config);
- * const command = new DescribeDeliveryStreamCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDeliveryStreamCommandInput} for command's `input` shape.
- * @see {@link DescribeDeliveryStreamCommandOutput} for command's `response` shape.
- * @see {@link FirehoseClientResolvedConfig | config} for command's `input` shape.
- *
- */
 class DescribeDeliveryStreamCommand 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/ListDeliveryStreamsCommand.js

@@ -5,42 +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 delivery streams in alphabetical order of their names.</p>
- *          <p>The number of delivery streams might be too large to return using a single call to
- *             <code>ListDeliveryStreams</code>. You can limit the number of delivery streams returned,
- *          using the <code>Limit</code> parameter. To determine whether there are more delivery
- *          streams to list, check the value of <code>HasMoreDeliveryStreams</code> in the output. If
- *          there are more delivery streams to list, you can request them by calling this operation
- *          again and setting the <code>ExclusiveStartDeliveryStreamName</code> parameter to the name
- *          of the last delivery stream returned in the last call.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { FirehoseClient, ListDeliveryStreamsCommand } from "@aws-sdk/client-firehose"; // ES Modules import
- * // const { FirehoseClient, ListDeliveryStreamsCommand } = require("@aws-sdk/client-firehose"); // CommonJS import
- * const client = new FirehoseClient(config);
- * const command = new ListDeliveryStreamsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListDeliveryStreamsCommandInput} for command's `input` shape.
- * @see {@link ListDeliveryStreamsCommandOutput} for command's `response` shape.
- * @see {@link FirehoseClientResolvedConfig | config} for command's `input` shape.
- *
- */
 class ListDeliveryStreamsCommand 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/ListTagsForDeliveryStreamCommand.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 delivery 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 { FirehoseClient, ListTagsForDeliveryStreamCommand } from "@aws-sdk/client-firehose"; // ES Modules import
- * // const { FirehoseClient, ListTagsForDeliveryStreamCommand } = require("@aws-sdk/client-firehose"); // CommonJS import
- * const client = new FirehoseClient(config);
- * const command = new ListTagsForDeliveryStreamCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsForDeliveryStreamCommandInput} for command's `input` shape.
- * @see {@link ListTagsForDeliveryStreamCommandOutput} for command's `response` shape.
- * @see {@link FirehoseClientResolvedConfig | config} for command's `input` shape.
- *
- */
 class ListTagsForDeliveryStreamCommand 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/PutRecordBatchCommand.js

@@ -5,85 +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 delivery stream in a single call, which can
- *          achieve higher throughput per producer than when writing single records. To write single
- *          data records into a delivery stream, use <a>PutRecord</a>. Applications using
- *          these operations are referred to as producers.</p>
- *          <p>For information about service quota, see <a href="https://docs.aws.amazon.com/firehose/latest/dev/limits.html">Amazon Kinesis Data Firehose
- *          Quota</a>.</p>
- *          <p>Each <a>PutRecordBatch</a> request supports up to 500 records. Each record
- *          in the request can be as large as 1,000 KB (before base64 encoding), up to a limit of 4 MB
- *          for the entire request. These limits cannot be changed.</p>
- *          <p>You must specify the name of the delivery stream and the data record when using <a>PutRecord</a>. The data record consists of a data blob that can be up to 1,000
- *          KB in size, and any kind of data. For example, it could be a segment from a log file,
- *          geographic location data, website clickstream data, and so on.</p>
- *          <p>Kinesis Data Firehose buffers records before delivering them to the destination. To
- *          disambiguate the data blobs at the destination, a common solution is to use delimiters in
- *          the data, such as a newline (<code>\n</code>) or some other character unique within the
- *          data. This allows the consumer application to parse individual data items when reading the
- *          data from the destination.</p>
- *          <p>The <a>PutRecordBatch</a> response includes a count of failed records,
- *             <code>FailedPutCount</code>, and an array of responses, <code>RequestResponses</code>.
- *          Even if the <a>PutRecordBatch</a> call succeeds, the value of
- *             <code>FailedPutCount</code> may be greater than 0, indicating that there are records for
- *          which the operation didn't succeed. Each entry in the <code>RequestResponses</code> array
- *          provides additional information about the processed record. It directly correlates with a
- *          record in the request array using the same ordering, from the top to the bottom. The
- *          response array always includes the same number of records as the request array.
- *             <code>RequestResponses</code> includes both successfully and unsuccessfully processed
- *          records. Kinesis Data Firehose tries to process all records in each <a>PutRecordBatch</a> request. A single record failure does not stop the processing
- *          of subsequent records. </p>
- *          <p>A successfully processed record includes a <code>RecordId</code> value, which is
- *          unique for the record. An unsuccessfully processed record includes <code>ErrorCode</code>
- *          and <code>ErrorMessage</code> values. <code>ErrorCode</code> reflects the type of error,
- *          and is one of the following values: <code>ServiceUnavailableException</code> or
- *             <code>InternalFailure</code>. <code>ErrorMessage</code> provides more detailed
- *          information about the error.</p>
- *          <p>If there is an internal server error or a timeout, the write might have completed or
- *          it might have failed. If <code>FailedPutCount</code> is greater than 0, retry the request,
- *          resending only those records that might have failed processing. This minimizes the possible
- *          duplicate records and also reduces the total bytes sent (and corresponding charges). We
- *          recommend that you handle any duplicates at the destination.</p>
- *          <p>If <a>PutRecordBatch</a> throws <code>ServiceUnavailableException</code>,
- *          back off and retry. If the exception persists, it is possible that the throughput limits
- *          have been exceeded for the delivery stream.</p>
- *
- *          <p>Data records sent to Kinesis Data Firehose are stored for 24 hours from the time they
- *          are added to a delivery stream as it attempts to send the records to the destination. If
- *          the destination is unreachable for more than 24 hours, the data is no longer
- *          available.</p>
- *          <important>
- *             <p>Don't concatenate two or more base64 strings to form the data fields of your records.
- *             Instead, concatenate the raw data, then perform base64 encoding.</p>
- *          </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { FirehoseClient, PutRecordBatchCommand } from "@aws-sdk/client-firehose"; // ES Modules import
- * // const { FirehoseClient, PutRecordBatchCommand } = require("@aws-sdk/client-firehose"); // CommonJS import
- * const client = new FirehoseClient(config);
- * const command = new PutRecordBatchCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutRecordBatchCommandInput} for command's `input` shape.
- * @see {@link PutRecordBatchCommandOutput} for command's `response` shape.
- * @see {@link FirehoseClientResolvedConfig | config} for command's `input` shape.
- *
- */
 class PutRecordBatchCommand 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,66 +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 Firehose delivery stream. To
- *          write multiple data records into a delivery stream, use <a>PutRecordBatch</a>.
- *          Applications using these operations are referred to as producers.</p>
- *          <p>By default, each delivery stream can take in up to 2,000 transactions per second,
- *          5,000 records per second, or 5 MB per second. If you use <a>PutRecord</a> and
- *             <a>PutRecordBatch</a>, the limits are an aggregate across these two
- *          operations for each delivery stream. For more information about limits and how to request
- *          an increase, see <a href="https://docs.aws.amazon.com/firehose/latest/dev/limits.html">Amazon
- *             Kinesis Data Firehose Limits</a>. </p>
- *          <p>You must specify the name of the delivery stream and the data record when using <a>PutRecord</a>. The data record consists of a data blob that can be up to 1,000
- *          KiB in size, and any kind of data. For example, it can be a segment from a log file,
- *          geographic location data, website clickstream data, and so on.</p>
- *          <p>Kinesis Data Firehose buffers records before delivering them to the destination. To
- *          disambiguate the data blobs at the destination, a common solution is to use delimiters in
- *          the data, such as a newline (<code>\n</code>) or some other character unique within the
- *          data. This allows the consumer application to parse individual data items when reading the
- *          data from the destination.</p>
- *          <p>The <code>PutRecord</code> operation returns a <code>RecordId</code>, which is a
- *          unique string assigned to each record. Producer applications can use this ID for purposes
- *          such as auditability and investigation.</p>
- *          <p>If the <code>PutRecord</code> operation throws a
- *             <code>ServiceUnavailableException</code>, back off and retry. If the exception persists,
- *          it is possible that the throughput limits have been exceeded for the delivery stream. </p>
- *          <p>Data records sent to Kinesis Data Firehose are stored for 24 hours from the time they
- *          are added to a delivery stream as it tries to send the records to the destination. If the
- *          destination is unreachable for more than 24 hours, the data is no longer
- *          available.</p>
- *
- *          <important>
- *             <p>Don't concatenate two or more base64 strings to form the data fields of your records.
- *             Instead, concatenate the raw data, then perform base64 encoding.</p>
- *          </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { FirehoseClient, PutRecordCommand } from "@aws-sdk/client-firehose"; // ES Modules import
- * // const { FirehoseClient, PutRecordCommand } = require("@aws-sdk/client-firehose"); // CommonJS import
- * const client = new FirehoseClient(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 FirehoseClientResolvedConfig | 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/StartDeliveryStreamEncryptionCommand.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>Enables server-side encryption (SSE) for the delivery stream. </p>
- *          <p>This operation is asynchronous. It returns immediately. When you invoke it, Kinesis Data
- *          Firehose first sets the encryption status of the stream to <code>ENABLING</code>, and then
- *          to <code>ENABLED</code>. The encryption status of a delivery stream is the
- *             <code>Status</code> property in <a>DeliveryStreamEncryptionConfiguration</a>.
- *          If the operation fails, the encryption status changes to <code>ENABLING_FAILED</code>. You
- *          can continue to read and write data to your delivery stream while the encryption status is
- *             <code>ENABLING</code>, but the data is not encrypted. It can take up to 5 seconds after
- *          the encryption status changes to <code>ENABLED</code> before all records written to the
- *          delivery stream are encrypted. To find out whether a record or a batch of records was
- *          encrypted, check the response elements <a>PutRecordOutput$Encrypted</a> and
- *             <a>PutRecordBatchOutput$Encrypted</a>, respectively.</p>
- *          <p>To check the encryption status of a delivery stream, use <a>DescribeDeliveryStream</a>.</p>
- *          <p>Even if encryption is currently enabled for a delivery stream, you can still invoke this
- *          operation on it to change the ARN of the CMK or both its type and ARN. If you invoke this
- *          method to change the CMK, and the old CMK is of type <code>CUSTOMER_MANAGED_CMK</code>,
- *          Kinesis Data Firehose schedules the grant it had on the old CMK for retirement. If the new
- *          CMK is of type <code>CUSTOMER_MANAGED_CMK</code>, Kinesis Data Firehose creates a grant
- *          that enables it to use the new CMK to encrypt and decrypt data and to manage the
- *          grant.</p>
- *          <p>If a delivery stream already has encryption enabled and then you invoke this operation
- *          to change the ARN of the CMK or both its type and ARN and you get
- *             <code>ENABLING_FAILED</code>, this only means that the attempt to change the CMK failed.
- *          In this case, encryption remains enabled with the old CMK.</p>
- *          <p>If the encryption status of your delivery stream is <code>ENABLING_FAILED</code>, you
- *          can invoke this operation again with a valid CMK. The CMK must be enabled and the key
- *          policy mustn't explicitly deny the permission for Kinesis Data Firehose to invoke KMS
- *          encrypt and decrypt operations.</p>
- *          <p>You can enable SSE for a delivery stream only if it's a delivery stream that uses
- *             <code>DirectPut</code> as its source. </p>
- *          <p>The <code>StartDeliveryStreamEncryption</code> and
- *             <code>StopDeliveryStreamEncryption</code> operations have a combined limit of 25 calls
- *          per delivery stream per 24 hours. For example, you reach the limit if you call
- *             <code>StartDeliveryStreamEncryption</code> 13 times and
- *             <code>StopDeliveryStreamEncryption</code> 12 times for the same delivery stream in a
- *          24-hour period.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { FirehoseClient, StartDeliveryStreamEncryptionCommand } from "@aws-sdk/client-firehose"; // ES Modules import
- * // const { FirehoseClient, StartDeliveryStreamEncryptionCommand } = require("@aws-sdk/client-firehose"); // CommonJS import
- * const client = new FirehoseClient(config);
- * const command = new StartDeliveryStreamEncryptionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartDeliveryStreamEncryptionCommandInput} for command's `input` shape.
- * @see {@link StartDeliveryStreamEncryptionCommandOutput} for command's `response` shape.
- * @see {@link FirehoseClientResolvedConfig | config} for command's `input` shape.
- *
- */
 class StartDeliveryStreamEncryptionCommand 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);