@aws-sdk/client-firehose 3.315.0 → 3.319.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/dist-cjs/Firehose.js +16 -168
  2. package/dist-es/Firehose.js +16 -168
  3. package/dist-types/Firehose.d.ts +23 -295
  4. package/dist-types/ts3.4/Firehose.d.ts +2 -1
  5. package/package.json +8 -8
package/dist-cjs/Firehose.js CHANGED
@@ -1,6 +1,7 @@
1
1
  "use strict";
2
2
  Object.defineProperty(exports, "__esModule", { value: true });
3
3
  exports.Firehose = void 0;
4
+ const smithy_client_1 = require("@aws-sdk/smithy-client");
4
5
  const CreateDeliveryStreamCommand_1 = require("./commands/CreateDeliveryStreamCommand");
5
6
  const DeleteDeliveryStreamCommand_1 = require("./commands/DeleteDeliveryStreamCommand");
6
7
  const DescribeDeliveryStreamCommand_1 = require("./commands/DescribeDeliveryStreamCommand");
@@ -14,174 +15,21 @@ const TagDeliveryStreamCommand_1 = require("./commands/TagDeliveryStreamCommand"
14
15
  const UntagDeliveryStreamCommand_1 = require("./commands/UntagDeliveryStreamCommand");
15
16
  const UpdateDestinationCommand_1 = require("./commands/UpdateDestinationCommand");
16
17
  const FirehoseClient_1 = require("./FirehoseClient");
18
+ const commands = {
19
+ CreateDeliveryStreamCommand: CreateDeliveryStreamCommand_1.CreateDeliveryStreamCommand,
20
+ DeleteDeliveryStreamCommand: DeleteDeliveryStreamCommand_1.DeleteDeliveryStreamCommand,
21
+ DescribeDeliveryStreamCommand: DescribeDeliveryStreamCommand_1.DescribeDeliveryStreamCommand,
22
+ ListDeliveryStreamsCommand: ListDeliveryStreamsCommand_1.ListDeliveryStreamsCommand,
23
+ ListTagsForDeliveryStreamCommand: ListTagsForDeliveryStreamCommand_1.ListTagsForDeliveryStreamCommand,
24
+ PutRecordCommand: PutRecordCommand_1.PutRecordCommand,
25
+ PutRecordBatchCommand: PutRecordBatchCommand_1.PutRecordBatchCommand,
26
+ StartDeliveryStreamEncryptionCommand: StartDeliveryStreamEncryptionCommand_1.StartDeliveryStreamEncryptionCommand,
27
+ StopDeliveryStreamEncryptionCommand: StopDeliveryStreamEncryptionCommand_1.StopDeliveryStreamEncryptionCommand,
28
+ TagDeliveryStreamCommand: TagDeliveryStreamCommand_1.TagDeliveryStreamCommand,
29
+ UntagDeliveryStreamCommand: UntagDeliveryStreamCommand_1.UntagDeliveryStreamCommand,
30
+ UpdateDestinationCommand: UpdateDestinationCommand_1.UpdateDestinationCommand,
31
+ };
17
32
  class Firehose extends FirehoseClient_1.FirehoseClient {
18
- createDeliveryStream(args, optionsOrCb, cb) {
19
- const command = new CreateDeliveryStreamCommand_1.CreateDeliveryStreamCommand(args);
20
- if (typeof optionsOrCb === "function") {
21
- this.send(command, optionsOrCb);
22
- }
23
- else if (typeof cb === "function") {
24
- if (typeof optionsOrCb !== "object")
25
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
26
- this.send(command, optionsOrCb || {}, cb);
27
- }
28
- else {
29
- return this.send(command, optionsOrCb);
30
- }
31
- }
32
- deleteDeliveryStream(args, optionsOrCb, cb) {
33
- const command = new DeleteDeliveryStreamCommand_1.DeleteDeliveryStreamCommand(args);
34
- if (typeof optionsOrCb === "function") {
35
- this.send(command, optionsOrCb);
36
- }
37
- else if (typeof cb === "function") {
38
- if (typeof optionsOrCb !== "object")
39
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
40
- this.send(command, optionsOrCb || {}, cb);
41
- }
42
- else {
43
- return this.send(command, optionsOrCb);
44
- }
45
- }
46
- describeDeliveryStream(args, optionsOrCb, cb) {
47
- const command = new DescribeDeliveryStreamCommand_1.DescribeDeliveryStreamCommand(args);
48
- if (typeof optionsOrCb === "function") {
49
- this.send(command, optionsOrCb);
50
- }
51
- else if (typeof cb === "function") {
52
- if (typeof optionsOrCb !== "object")
53
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
54
- this.send(command, optionsOrCb || {}, cb);
55
- }
56
- else {
57
- return this.send(command, optionsOrCb);
58
- }
59
- }
60
- listDeliveryStreams(args, optionsOrCb, cb) {
61
- const command = new ListDeliveryStreamsCommand_1.ListDeliveryStreamsCommand(args);
62
- if (typeof optionsOrCb === "function") {
63
- this.send(command, optionsOrCb);
64
- }
65
- else if (typeof cb === "function") {
66
- if (typeof optionsOrCb !== "object")
67
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
68
- this.send(command, optionsOrCb || {}, cb);
69
- }
70
- else {
71
- return this.send(command, optionsOrCb);
72
- }
73
- }
74
- listTagsForDeliveryStream(args, optionsOrCb, cb) {
75
- const command = new ListTagsForDeliveryStreamCommand_1.ListTagsForDeliveryStreamCommand(args);
76
- if (typeof optionsOrCb === "function") {
77
- this.send(command, optionsOrCb);
78
- }
79
- else if (typeof cb === "function") {
80
- if (typeof optionsOrCb !== "object")
81
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
82
- this.send(command, optionsOrCb || {}, cb);
83
- }
84
- else {
85
- return this.send(command, optionsOrCb);
86
- }
87
- }
88
- putRecord(args, optionsOrCb, cb) {
89
- const command = new PutRecordCommand_1.PutRecordCommand(args);
90
- if (typeof optionsOrCb === "function") {
91
- this.send(command, optionsOrCb);
92
- }
93
- else if (typeof cb === "function") {
94
- if (typeof optionsOrCb !== "object")
95
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
96
- this.send(command, optionsOrCb || {}, cb);
97
- }
98
- else {
99
- return this.send(command, optionsOrCb);
100
- }
101
- }
102
- putRecordBatch(args, optionsOrCb, cb) {
103
- const command = new PutRecordBatchCommand_1.PutRecordBatchCommand(args);
104
- if (typeof optionsOrCb === "function") {
105
- this.send(command, optionsOrCb);
106
- }
107
- else if (typeof cb === "function") {
108
- if (typeof optionsOrCb !== "object")
109
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
110
- this.send(command, optionsOrCb || {}, cb);
111
- }
112
- else {
113
- return this.send(command, optionsOrCb);
114
- }
115
- }
116
- startDeliveryStreamEncryption(args, optionsOrCb, cb) {
117
- const command = new StartDeliveryStreamEncryptionCommand_1.StartDeliveryStreamEncryptionCommand(args);
118
- if (typeof optionsOrCb === "function") {
119
- this.send(command, optionsOrCb);
120
- }
121
- else if (typeof cb === "function") {
122
- if (typeof optionsOrCb !== "object")
123
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
124
- this.send(command, optionsOrCb || {}, cb);
125
- }
126
- else {
127
- return this.send(command, optionsOrCb);
128
- }
129
- }
130
- stopDeliveryStreamEncryption(args, optionsOrCb, cb) {
131
- const command = new StopDeliveryStreamEncryptionCommand_1.StopDeliveryStreamEncryptionCommand(args);
132
- if (typeof optionsOrCb === "function") {
133
- this.send(command, optionsOrCb);
134
- }
135
- else if (typeof cb === "function") {
136
- if (typeof optionsOrCb !== "object")
137
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
138
- this.send(command, optionsOrCb || {}, cb);
139
- }
140
- else {
141
- return this.send(command, optionsOrCb);
142
- }
143
- }
144
- tagDeliveryStream(args, optionsOrCb, cb) {
145
- const command = new TagDeliveryStreamCommand_1.TagDeliveryStreamCommand(args);
146
- if (typeof optionsOrCb === "function") {
147
- this.send(command, optionsOrCb);
148
- }
149
- else if (typeof cb === "function") {
150
- if (typeof optionsOrCb !== "object")
151
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
152
- this.send(command, optionsOrCb || {}, cb);
153
- }
154
- else {
155
- return this.send(command, optionsOrCb);
156
- }
157
- }
158
- untagDeliveryStream(args, optionsOrCb, cb) {
159
- const command = new UntagDeliveryStreamCommand_1.UntagDeliveryStreamCommand(args);
160
- if (typeof optionsOrCb === "function") {
161
- this.send(command, optionsOrCb);
162
- }
163
- else if (typeof cb === "function") {
164
- if (typeof optionsOrCb !== "object")
165
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
166
- this.send(command, optionsOrCb || {}, cb);
167
- }
168
- else {
169
- return this.send(command, optionsOrCb);
170
- }
171
- }
172
- updateDestination(args, optionsOrCb, cb) {
173
- const command = new UpdateDestinationCommand_1.UpdateDestinationCommand(args);
174
- if (typeof optionsOrCb === "function") {
175
- this.send(command, optionsOrCb);
176
- }
177
- else if (typeof cb === "function") {
178
- if (typeof optionsOrCb !== "object")
179
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
180
- this.send(command, optionsOrCb || {}, cb);
181
- }
182
- else {
183
- return this.send(command, optionsOrCb);
184
- }
185
- }
186
33
  }
187
34
  exports.Firehose = Firehose;
35
+ (0, smithy_client_1.createAggregatedClient)(commands, Firehose);
package/dist-es/Firehose.js CHANGED
@@ -1,3 +1,4 @@
1
+ import { createAggregatedClient } from "@aws-sdk/smithy-client";
1
2
  import { CreateDeliveryStreamCommand, } from "./commands/CreateDeliveryStreamCommand";
2
3
  import { DeleteDeliveryStreamCommand, } from "./commands/DeleteDeliveryStreamCommand";
3
4
  import { DescribeDeliveryStreamCommand, } from "./commands/DescribeDeliveryStreamCommand";
@@ -11,173 +12,20 @@ import { TagDeliveryStreamCommand, } from "./commands/TagDeliveryStreamCommand";
11
12
  import { UntagDeliveryStreamCommand, } from "./commands/UntagDeliveryStreamCommand";
12
13
  import { UpdateDestinationCommand, } from "./commands/UpdateDestinationCommand";
13
14
  import { FirehoseClient } from "./FirehoseClient";
15
+ const commands = {
16
+ CreateDeliveryStreamCommand,
17
+ DeleteDeliveryStreamCommand,
18
+ DescribeDeliveryStreamCommand,
19
+ ListDeliveryStreamsCommand,
20
+ ListTagsForDeliveryStreamCommand,
21
+ PutRecordCommand,
22
+ PutRecordBatchCommand,
23
+ StartDeliveryStreamEncryptionCommand,
24
+ StopDeliveryStreamEncryptionCommand,
25
+ TagDeliveryStreamCommand,
26
+ UntagDeliveryStreamCommand,
27
+ UpdateDestinationCommand,
28
+ };
14
29
  export class Firehose extends FirehoseClient {
15
- createDeliveryStream(args, optionsOrCb, cb) {
16
- const command = new CreateDeliveryStreamCommand(args);
17
- if (typeof optionsOrCb === "function") {
18
- this.send(command, optionsOrCb);
19
- }
20
- else if (typeof cb === "function") {
21
- if (typeof optionsOrCb !== "object")
22
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
23
- this.send(command, optionsOrCb || {}, cb);
24
- }
25
- else {
26
- return this.send(command, optionsOrCb);
27
- }
28
- }
29
- deleteDeliveryStream(args, optionsOrCb, cb) {
30
- const command = new DeleteDeliveryStreamCommand(args);
31
- if (typeof optionsOrCb === "function") {
32
- this.send(command, optionsOrCb);
33
- }
34
- else if (typeof cb === "function") {
35
- if (typeof optionsOrCb !== "object")
36
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
37
- this.send(command, optionsOrCb || {}, cb);
38
- }
39
- else {
40
- return this.send(command, optionsOrCb);
41
- }
42
- }
43
- describeDeliveryStream(args, optionsOrCb, cb) {
44
- const command = new DescribeDeliveryStreamCommand(args);
45
- if (typeof optionsOrCb === "function") {
46
- this.send(command, optionsOrCb);
47
- }
48
- else if (typeof cb === "function") {
49
- if (typeof optionsOrCb !== "object")
50
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
51
- this.send(command, optionsOrCb || {}, cb);
52
- }
53
- else {
54
- return this.send(command, optionsOrCb);
55
- }
56
- }
57
- listDeliveryStreams(args, optionsOrCb, cb) {
58
- const command = new ListDeliveryStreamsCommand(args);
59
- if (typeof optionsOrCb === "function") {
60
- this.send(command, optionsOrCb);
61
- }
62
- else if (typeof cb === "function") {
63
- if (typeof optionsOrCb !== "object")
64
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
65
- this.send(command, optionsOrCb || {}, cb);
66
- }
67
- else {
68
- return this.send(command, optionsOrCb);
69
- }
70
- }
71
- listTagsForDeliveryStream(args, optionsOrCb, cb) {
72
- const command = new ListTagsForDeliveryStreamCommand(args);
73
- if (typeof optionsOrCb === "function") {
74
- this.send(command, optionsOrCb);
75
- }
76
- else if (typeof cb === "function") {
77
- if (typeof optionsOrCb !== "object")
78
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
79
- this.send(command, optionsOrCb || {}, cb);
80
- }
81
- else {
82
- return this.send(command, optionsOrCb);
83
- }
84
- }
85
- putRecord(args, optionsOrCb, cb) {
86
- const command = new PutRecordCommand(args);
87
- if (typeof optionsOrCb === "function") {
88
- this.send(command, optionsOrCb);
89
- }
90
- else if (typeof cb === "function") {
91
- if (typeof optionsOrCb !== "object")
92
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
93
- this.send(command, optionsOrCb || {}, cb);
94
- }
95
- else {
96
- return this.send(command, optionsOrCb);
97
- }
98
- }
99
- putRecordBatch(args, optionsOrCb, cb) {
100
- const command = new PutRecordBatchCommand(args);
101
- if (typeof optionsOrCb === "function") {
102
- this.send(command, optionsOrCb);
103
- }
104
- else if (typeof cb === "function") {
105
- if (typeof optionsOrCb !== "object")
106
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
107
- this.send(command, optionsOrCb || {}, cb);
108
- }
109
- else {
110
- return this.send(command, optionsOrCb);
111
- }
112
- }
113
- startDeliveryStreamEncryption(args, optionsOrCb, cb) {
114
- const command = new StartDeliveryStreamEncryptionCommand(args);
115
- if (typeof optionsOrCb === "function") {
116
- this.send(command, optionsOrCb);
117
- }
118
- else if (typeof cb === "function") {
119
- if (typeof optionsOrCb !== "object")
120
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
121
- this.send(command, optionsOrCb || {}, cb);
122
- }
123
- else {
124
- return this.send(command, optionsOrCb);
125
- }
126
- }
127
- stopDeliveryStreamEncryption(args, optionsOrCb, cb) {
128
- const command = new StopDeliveryStreamEncryptionCommand(args);
129
- if (typeof optionsOrCb === "function") {
130
- this.send(command, optionsOrCb);
131
- }
132
- else if (typeof cb === "function") {
133
- if (typeof optionsOrCb !== "object")
134
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
135
- this.send(command, optionsOrCb || {}, cb);
136
- }
137
- else {
138
- return this.send(command, optionsOrCb);
139
- }
140
- }
141
- tagDeliveryStream(args, optionsOrCb, cb) {
142
- const command = new TagDeliveryStreamCommand(args);
143
- if (typeof optionsOrCb === "function") {
144
- this.send(command, optionsOrCb);
145
- }
146
- else if (typeof cb === "function") {
147
- if (typeof optionsOrCb !== "object")
148
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
149
- this.send(command, optionsOrCb || {}, cb);
150
- }
151
- else {
152
- return this.send(command, optionsOrCb);
153
- }
154
- }
155
- untagDeliveryStream(args, optionsOrCb, cb) {
156
- const command = new UntagDeliveryStreamCommand(args);
157
- if (typeof optionsOrCb === "function") {
158
- this.send(command, optionsOrCb);
159
- }
160
- else if (typeof cb === "function") {
161
- if (typeof optionsOrCb !== "object")
162
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
163
- this.send(command, optionsOrCb || {}, cb);
164
- }
165
- else {
166
- return this.send(command, optionsOrCb);
167
- }
168
- }
169
- updateDestination(args, optionsOrCb, cb) {
170
- const command = new UpdateDestinationCommand(args);
171
- if (typeof optionsOrCb === "function") {
172
- this.send(command, optionsOrCb);
173
- }
174
- else if (typeof cb === "function") {
175
- if (typeof optionsOrCb !== "object")
176
- throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
177
- this.send(command, optionsOrCb || {}, cb);
178
- }
179
- else {
180
- return this.send(command, optionsOrCb);
181
- }
182
- }
183
30
  }
31
+ createAggregatedClient(commands, Firehose);
package/dist-types/Firehose.d.ts CHANGED
@@ -12,359 +12,87 @@ import { TagDeliveryStreamCommandInput, TagDeliveryStreamCommandOutput } from ".
12
12
  import { UntagDeliveryStreamCommandInput, UntagDeliveryStreamCommandOutput } from "./commands/UntagDeliveryStreamCommand";
13
13
  import { UpdateDestinationCommandInput, UpdateDestinationCommandOutput } from "./commands/UpdateDestinationCommand";
14
14
  import { FirehoseClient } from "./FirehoseClient";
15
- /**
16
- * @public
17
- * <fullname>Amazon Kinesis Data Firehose API Reference</fullname>
18
- * <p>Amazon Kinesis Data Firehose is a fully managed service that delivers real-time
19
- * streaming data to destinations such as Amazon Simple Storage Service (Amazon S3), Amazon
20
- * OpenSearch Service, Amazon Redshift, Splunk, and various other supportd
21
- * destinations.</p>
22
- */
23
- export declare class Firehose extends FirehoseClient {
15
+ export interface Firehose {
24
16
  /**
25
- * @public
26
- * <p>Creates a Kinesis Data Firehose delivery stream.</p>
27
- *
28
- * <p>By default, you can create up to 50 delivery streams per Amazon Web Services
29
- * Region.</p>
30
- * <p>This is an asynchronous operation that immediately returns. The initial status of the
31
- * delivery stream is <code>CREATING</code>. After the delivery stream is created, its status
32
- * is <code>ACTIVE</code> and it now accepts data. If the delivery stream creation fails, the
33
- * status transitions to <code>CREATING_FAILED</code>. Attempts to send data to a delivery
34
- * stream that is not in the <code>ACTIVE</code> state cause an exception. To check the state
35
- * of a delivery stream, use <a>DescribeDeliveryStream</a>.</p>
36
- * <p>If the status of a delivery stream is <code>CREATING_FAILED</code>, this status
37
- * doesn't change, and you can't invoke <code>CreateDeliveryStream</code> again on it.
38
- * However, you can invoke the <a>DeleteDeliveryStream</a> operation to delete
39
- * it.</p>
40
- * <p>A Kinesis Data Firehose delivery stream can be configured to receive records directly
41
- * from providers using <a>PutRecord</a> or <a>PutRecordBatch</a>, or it
42
- * can be configured to use an existing Kinesis stream as its source. To specify a Kinesis
43
- * data stream as input, set the <code>DeliveryStreamType</code> parameter to
44
- * <code>KinesisStreamAsSource</code>, and provide the Kinesis stream Amazon Resource Name
45
- * (ARN) and role ARN in the <code>KinesisStreamSourceConfiguration</code>
46
- * parameter.</p>
47
- * <p>To create a delivery stream with server-side encryption (SSE) enabled, include <a>DeliveryStreamEncryptionConfigurationInput</a> in your request. This is
48
- * optional. You can also invoke <a>StartDeliveryStreamEncryption</a> to turn on
49
- * SSE for an existing delivery stream that doesn't have SSE enabled.</p>
50
- * <p>A delivery stream is configured with a single destination: Amazon S3, Amazon ES,
51
- * Amazon Redshift, or Splunk. You must specify only one of the following destination
52
- * configuration parameters: <code>ExtendedS3DestinationConfiguration</code>,
53
- * <code>S3DestinationConfiguration</code>,
54
- * <code>ElasticsearchDestinationConfiguration</code>,
55
- * <code>RedshiftDestinationConfiguration</code>, or
56
- * <code>SplunkDestinationConfiguration</code>.</p>
57
- * <p>When you specify <code>S3DestinationConfiguration</code>, you can also provide the
58
- * following optional values: BufferingHints, <code>EncryptionConfiguration</code>, and
59
- * <code>CompressionFormat</code>. By default, if no <code>BufferingHints</code> value is
60
- * provided, Kinesis Data Firehose buffers data up to 5 MB or for 5 minutes, whichever
61
- * condition is satisfied first. <code>BufferingHints</code> is a hint, so there are some
62
- * cases where the service cannot adhere to these conditions strictly. For example, record
63
- * boundaries might be such that the size is a little over or under the configured buffering
64
- * size. By default, no encryption is performed. We strongly recommend that you enable
65
- * encryption to ensure secure data storage in Amazon S3.</p>
66
- *
67
- * <p>A few notes about Amazon Redshift as a destination:</p>
68
- * <ul>
69
- * <li>
70
- * <p>An Amazon Redshift destination requires an S3 bucket as intermediate location.
71
- * Kinesis Data Firehose first delivers data to Amazon S3 and then uses
72
- * <code>COPY</code> syntax to load data into an Amazon Redshift table. This is
73
- * specified in the <code>RedshiftDestinationConfiguration.S3Configuration</code>
74
- * parameter.</p>
75
- *
76
- * </li>
77
- * <li>
78
- * <p>The compression formats <code>SNAPPY</code> or <code>ZIP</code> cannot be
79
- * specified in <code>RedshiftDestinationConfiguration.S3Configuration</code> because
80
- * the Amazon Redshift <code>COPY</code> operation that reads from the S3 bucket doesn't
81
- * support these compression formats.</p>
82
- * </li>
83
- * <li>
84
- * <p>We strongly recommend that you use the user name and password you provide
85
- * exclusively with Kinesis Data Firehose, and that the permissions for the account are
86
- * restricted for Amazon Redshift <code>INSERT</code> permissions.</p>
87
- *
88
- * </li>
89
- * </ul>
90
- * <p>Kinesis Data Firehose assumes the IAM role that is configured as part of the
91
- * destination. The role should allow the Kinesis Data Firehose principal to assume the role,
92
- * and the role should have permissions that allow the service to deliver the data. For more
93
- * information, see <a href="https://docs.aws.amazon.com/firehose/latest/dev/controlling-access.html#using-iam-s3">Grant Kinesis Data
94
- * Firehose Access to an Amazon S3 Destination</a> in the <i>Amazon Kinesis Data
95
- * Firehose Developer Guide</i>.</p>
17
+ * @see {@link CreateDeliveryStreamCommand}
96
18
  */
97
19
  createDeliveryStream(args: CreateDeliveryStreamCommandInput, options?: __HttpHandlerOptions): Promise<CreateDeliveryStreamCommandOutput>;
98
20
  createDeliveryStream(args: CreateDeliveryStreamCommandInput, cb: (err: any, data?: CreateDeliveryStreamCommandOutput) => void): void;
99
21
  createDeliveryStream(args: CreateDeliveryStreamCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateDeliveryStreamCommandOutput) => void): void;
100
22
  /**
101
- * @public
102
- * <p>Deletes a delivery stream and its data.</p>
103
- * <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:
104
- * <code>ACTIVE</code>, <code>DELETING</code>, <code>CREATING_FAILED</code>, or
105
- * <code>DELETING_FAILED</code>. You can't delete a delivery stream that is in the
106
- * <code>CREATING</code> state. While the deletion request is in process, the delivery
107
- * stream is in the <code>DELETING</code> state.</p>
108
- * <p>While the delivery stream is in the <code>DELETING</code> state, the service might
109
- * continue to accept records, but it doesn't make any guarantees with respect to delivering
110
- * the data. Therefore, as a best practice, first stop any applications that are sending
111
- * records before you delete a delivery stream.</p>
23
+ * @see {@link DeleteDeliveryStreamCommand}
112
24
  */
113
25
  deleteDeliveryStream(args: DeleteDeliveryStreamCommandInput, options?: __HttpHandlerOptions): Promise<DeleteDeliveryStreamCommandOutput>;
114
26
  deleteDeliveryStream(args: DeleteDeliveryStreamCommandInput, cb: (err: any, data?: DeleteDeliveryStreamCommandOutput) => void): void;
115
27
  deleteDeliveryStream(args: DeleteDeliveryStreamCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteDeliveryStreamCommandOutput) => void): void;
116
28
  /**
117
- * @public
118
- * <p>Describes the specified delivery stream and its status. For example, after your
119
- * delivery stream is created, call <code>DescribeDeliveryStream</code> to see whether the
120
- * delivery stream is <code>ACTIVE</code> and therefore ready for data to be sent to it. </p>
121
- * <p>If the status of a delivery stream is <code>CREATING_FAILED</code>, this status
122
- * doesn't change, and you can't invoke <a>CreateDeliveryStream</a> again on it.
123
- * However, you can invoke the <a>DeleteDeliveryStream</a> operation to delete it.
124
- * 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>
29
+ * @see {@link DescribeDeliveryStreamCommand}
125
30
  */
126
31
  describeDeliveryStream(args: DescribeDeliveryStreamCommandInput, options?: __HttpHandlerOptions): Promise<DescribeDeliveryStreamCommandOutput>;
127
32
  describeDeliveryStream(args: DescribeDeliveryStreamCommandInput, cb: (err: any, data?: DescribeDeliveryStreamCommandOutput) => void): void;
128
33
  describeDeliveryStream(args: DescribeDeliveryStreamCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeDeliveryStreamCommandOutput) => void): void;
129
34
  /**
130
- * @public
131
- * <p>Lists your delivery streams in alphabetical order of their names.</p>
132
- * <p>The number of delivery streams might be too large to return using a single call to
133
- * <code>ListDeliveryStreams</code>. You can limit the number of delivery streams returned,
134
- * using the <code>Limit</code> parameter. To determine whether there are more delivery
135
- * streams to list, check the value of <code>HasMoreDeliveryStreams</code> in the output. If
136
- * there are more delivery streams to list, you can request them by calling this operation
137
- * again and setting the <code>ExclusiveStartDeliveryStreamName</code> parameter to the name
138
- * of the last delivery stream returned in the last call.</p>
35
+ * @see {@link ListDeliveryStreamsCommand}
139
36
  */
140
37
  listDeliveryStreams(args: ListDeliveryStreamsCommandInput, options?: __HttpHandlerOptions): Promise<ListDeliveryStreamsCommandOutput>;
141
38
  listDeliveryStreams(args: ListDeliveryStreamsCommandInput, cb: (err: any, data?: ListDeliveryStreamsCommandOutput) => void): void;
142
39
  listDeliveryStreams(args: ListDeliveryStreamsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListDeliveryStreamsCommandOutput) => void): void;
143
40
  /**
144
- * @public
145
- * <p>Lists the tags for the specified delivery stream. This operation has a limit of five
146
- * transactions per second per account. </p>
41
+ * @see {@link ListTagsForDeliveryStreamCommand}
147
42
  */
148
43
  listTagsForDeliveryStream(args: ListTagsForDeliveryStreamCommandInput, options?: __HttpHandlerOptions): Promise<ListTagsForDeliveryStreamCommandOutput>;
149
44
  listTagsForDeliveryStream(args: ListTagsForDeliveryStreamCommandInput, cb: (err: any, data?: ListTagsForDeliveryStreamCommandOutput) => void): void;
150
45
  listTagsForDeliveryStream(args: ListTagsForDeliveryStreamCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTagsForDeliveryStreamCommandOutput) => void): void;
151
46
  /**
152
- * @public
153
- * <p>Writes a single data record into an Amazon Kinesis Data Firehose delivery stream. To
154
- * write multiple data records into a delivery stream, use <a>PutRecordBatch</a>.
155
- * Applications using these operations are referred to as producers.</p>
156
- * <p>By default, each delivery stream can take in up to 2,000 transactions per second,
157
- * 5,000 records per second, or 5 MB per second. If you use <a>PutRecord</a> and
158
- * <a>PutRecordBatch</a>, the limits are an aggregate across these two
159
- * operations for each delivery stream. For more information about limits and how to request
160
- * an increase, see <a href="https://docs.aws.amazon.com/firehose/latest/dev/limits.html">Amazon
161
- * Kinesis Data Firehose Limits</a>. </p>
162
- * <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
163
- * KiB in size, and any kind of data. For example, it can be a segment from a log file,
164
- * geographic location data, website clickstream data, and so on.</p>
165
- * <p>Kinesis Data Firehose buffers records before delivering them to the destination. To
166
- * disambiguate the data blobs at the destination, a common solution is to use delimiters in
167
- * the data, such as a newline (<code>\n</code>) or some other character unique within the
168
- * data. This allows the consumer application to parse individual data items when reading the
169
- * data from the destination.</p>
170
- * <p>The <code>PutRecord</code> operation returns a <code>RecordId</code>, which is a
171
- * unique string assigned to each record. Producer applications can use this ID for purposes
172
- * such as auditability and investigation.</p>
173
- * <p>If the <code>PutRecord</code> operation throws a
174
- * <code>ServiceUnavailableException</code>, back off and retry. If the exception persists,
175
- * it is possible that the throughput limits have been exceeded for the delivery stream. </p>
176
- * <p>Data records sent to Kinesis Data Firehose are stored for 24 hours from the time they
177
- * are added to a delivery stream as it tries to send the records to the destination. If the
178
- * destination is unreachable for more than 24 hours, the data is no longer
179
- * available.</p>
180
- *
181
- * <important>
182
- * <p>Don't concatenate two or more base64 strings to form the data fields of your records.
183
- * Instead, concatenate the raw data, then perform base64 encoding.</p>
184
- * </important>
47
+ * @see {@link PutRecordCommand}
185
48
  */
186
49
  putRecord(args: PutRecordCommandInput, options?: __HttpHandlerOptions): Promise<PutRecordCommandOutput>;
187
50
  putRecord(args: PutRecordCommandInput, cb: (err: any, data?: PutRecordCommandOutput) => void): void;
188
51
  putRecord(args: PutRecordCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutRecordCommandOutput) => void): void;
189
52
  /**
190
- * @public
191
- * <p>Writes multiple data records into a delivery stream in a single call, which can
192
- * achieve higher throughput per producer than when writing single records. To write single
193
- * data records into a delivery stream, use <a>PutRecord</a>. Applications using
194
- * these operations are referred to as producers.</p>
195
- * <p>For information about service quota, see <a href="https://docs.aws.amazon.com/firehose/latest/dev/limits.html">Amazon Kinesis Data Firehose
196
- * Quota</a>.</p>
197
- * <p>Each <a>PutRecordBatch</a> request supports up to 500 records. Each record
198
- * in the request can be as large as 1,000 KB (before base64 encoding), up to a limit of 4 MB
199
- * for the entire request. These limits cannot be changed.</p>
200
- * <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
201
- * KB in size, and any kind of data. For example, it could be a segment from a log file,
202
- * geographic location data, website clickstream data, and so on.</p>
203
- * <p>Kinesis Data Firehose buffers records before delivering them to the destination. To
204
- * disambiguate the data blobs at the destination, a common solution is to use delimiters in
205
- * the data, such as a newline (<code>\n</code>) or some other character unique within the
206
- * data. This allows the consumer application to parse individual data items when reading the
207
- * data from the destination.</p>
208
- * <p>The <a>PutRecordBatch</a> response includes a count of failed records,
209
- * <code>FailedPutCount</code>, and an array of responses, <code>RequestResponses</code>.
210
- * Even if the <a>PutRecordBatch</a> call succeeds, the value of
211
- * <code>FailedPutCount</code> may be greater than 0, indicating that there are records for
212
- * which the operation didn't succeed. Each entry in the <code>RequestResponses</code> array
213
- * provides additional information about the processed record. It directly correlates with a
214
- * record in the request array using the same ordering, from the top to the bottom. The
215
- * response array always includes the same number of records as the request array.
216
- * <code>RequestResponses</code> includes both successfully and unsuccessfully processed
217
- * records. Kinesis Data Firehose tries to process all records in each <a>PutRecordBatch</a> request. A single record failure does not stop the processing
218
- * of subsequent records. </p>
219
- * <p>A successfully processed record includes a <code>RecordId</code> value, which is
220
- * unique for the record. An unsuccessfully processed record includes <code>ErrorCode</code>
221
- * and <code>ErrorMessage</code> values. <code>ErrorCode</code> reflects the type of error,
222
- * and is one of the following values: <code>ServiceUnavailableException</code> or
223
- * <code>InternalFailure</code>. <code>ErrorMessage</code> provides more detailed
224
- * information about the error.</p>
225
- * <p>If there is an internal server error or a timeout, the write might have completed or
226
- * it might have failed. If <code>FailedPutCount</code> is greater than 0, retry the request,
227
- * resending only those records that might have failed processing. This minimizes the possible
228
- * duplicate records and also reduces the total bytes sent (and corresponding charges). We
229
- * recommend that you handle any duplicates at the destination.</p>
230
- * <p>If <a>PutRecordBatch</a> throws <code>ServiceUnavailableException</code>,
231
- * back off and retry. If the exception persists, it is possible that the throughput limits
232
- * have been exceeded for the delivery stream.</p>
233
- *
234
- * <p>Data records sent to Kinesis Data Firehose are stored for 24 hours from the time they
235
- * are added to a delivery stream as it attempts to send the records to the destination. If
236
- * the destination is unreachable for more than 24 hours, the data is no longer
237
- * available.</p>
238
- * <important>
239
- * <p>Don't concatenate two or more base64 strings to form the data fields of your records.
240
- * Instead, concatenate the raw data, then perform base64 encoding.</p>
241
- * </important>
53
+ * @see {@link PutRecordBatchCommand}
242
54
  */
243
55
  putRecordBatch(args: PutRecordBatchCommandInput, options?: __HttpHandlerOptions): Promise<PutRecordBatchCommandOutput>;
244
56
  putRecordBatch(args: PutRecordBatchCommandInput, cb: (err: any, data?: PutRecordBatchCommandOutput) => void): void;
245
57
  putRecordBatch(args: PutRecordBatchCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutRecordBatchCommandOutput) => void): void;
246
58
  /**
247
- * @public
248
- * <p>Enables server-side encryption (SSE) for the delivery stream. </p>
249
- * <p>This operation is asynchronous. It returns immediately. When you invoke it, Kinesis Data
250
- * Firehose first sets the encryption status of the stream to <code>ENABLING</code>, and then
251
- * to <code>ENABLED</code>. The encryption status of a delivery stream is the
252
- * <code>Status</code> property in <a>DeliveryStreamEncryptionConfiguration</a>.
253
- * If the operation fails, the encryption status changes to <code>ENABLING_FAILED</code>. You
254
- * can continue to read and write data to your delivery stream while the encryption status is
255
- * <code>ENABLING</code>, but the data is not encrypted. It can take up to 5 seconds after
256
- * the encryption status changes to <code>ENABLED</code> before all records written to the
257
- * delivery stream are encrypted. To find out whether a record or a batch of records was
258
- * encrypted, check the response elements <a>PutRecordOutput$Encrypted</a> and
259
- * <a>PutRecordBatchOutput$Encrypted</a>, respectively.</p>
260
- * <p>To check the encryption status of a delivery stream, use <a>DescribeDeliveryStream</a>.</p>
261
- * <p>Even if encryption is currently enabled for a delivery stream, you can still invoke this
262
- * operation on it to change the ARN of the CMK or both its type and ARN. If you invoke this
263
- * method to change the CMK, and the old CMK is of type <code>CUSTOMER_MANAGED_CMK</code>,
264
- * Kinesis Data Firehose schedules the grant it had on the old CMK for retirement. If the new
265
- * CMK is of type <code>CUSTOMER_MANAGED_CMK</code>, Kinesis Data Firehose creates a grant
266
- * that enables it to use the new CMK to encrypt and decrypt data and to manage the
267
- * grant.</p>
268
- * <p>If a delivery stream already has encryption enabled and then you invoke this operation
269
- * to change the ARN of the CMK or both its type and ARN and you get
270
- * <code>ENABLING_FAILED</code>, this only means that the attempt to change the CMK failed.
271
- * In this case, encryption remains enabled with the old CMK.</p>
272
- * <p>If the encryption status of your delivery stream is <code>ENABLING_FAILED</code>, you
273
- * can invoke this operation again with a valid CMK. The CMK must be enabled and the key
274
- * policy mustn't explicitly deny the permission for Kinesis Data Firehose to invoke KMS
275
- * encrypt and decrypt operations.</p>
276
- * <p>You can enable SSE for a delivery stream only if it's a delivery stream that uses
277
- * <code>DirectPut</code> as its source. </p>
278
- * <p>The <code>StartDeliveryStreamEncryption</code> and
279
- * <code>StopDeliveryStreamEncryption</code> operations have a combined limit of 25 calls
280
- * per delivery stream per 24 hours. For example, you reach the limit if you call
281
- * <code>StartDeliveryStreamEncryption</code> 13 times and
282
- * <code>StopDeliveryStreamEncryption</code> 12 times for the same delivery stream in a
283
- * 24-hour period.</p>
59
+ * @see {@link StartDeliveryStreamEncryptionCommand}
284
60
  */
285
61
  startDeliveryStreamEncryption(args: StartDeliveryStreamEncryptionCommandInput, options?: __HttpHandlerOptions): Promise<StartDeliveryStreamEncryptionCommandOutput>;
286
62
  startDeliveryStreamEncryption(args: StartDeliveryStreamEncryptionCommandInput, cb: (err: any, data?: StartDeliveryStreamEncryptionCommandOutput) => void): void;
287
63
  startDeliveryStreamEncryption(args: StartDeliveryStreamEncryptionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartDeliveryStreamEncryptionCommandOutput) => void): void;
288
64
  /**
289
- * @public
290
- * <p>Disables server-side encryption (SSE) for the delivery stream. </p>
291
- * <p>This operation is asynchronous. It returns immediately. When you invoke it, Kinesis Data
292
- * Firehose first sets the encryption status of the stream to <code>DISABLING</code>, and then
293
- * to <code>DISABLED</code>. You can continue to read and write data to your stream while its
294
- * status is <code>DISABLING</code>. It can take up to 5 seconds after the encryption status
295
- * changes to <code>DISABLED</code> before all records written to the delivery stream are no
296
- * longer subject to encryption. To find out whether a record or a batch of records was
297
- * encrypted, check the response elements <a>PutRecordOutput$Encrypted</a> and
298
- * <a>PutRecordBatchOutput$Encrypted</a>, respectively.</p>
299
- * <p>To check the encryption state of a delivery stream, use <a>DescribeDeliveryStream</a>. </p>
300
- * <p>If SSE is enabled using a customer managed CMK and then you invoke
301
- * <code>StopDeliveryStreamEncryption</code>, Kinesis Data Firehose schedules the related
302
- * KMS grant for retirement and then retires it after it ensures that it is finished
303
- * delivering records to the destination.</p>
304
- * <p>The <code>StartDeliveryStreamEncryption</code> and
305
- * <code>StopDeliveryStreamEncryption</code> operations have a combined limit of 25 calls
306
- * per delivery stream per 24 hours. For example, you reach the limit if you call
307
- * <code>StartDeliveryStreamEncryption</code> 13 times and
308
- * <code>StopDeliveryStreamEncryption</code> 12 times for the same delivery stream in a
309
- * 24-hour period.</p>
65
+ * @see {@link StopDeliveryStreamEncryptionCommand}
310
66
  */
311
67
  stopDeliveryStreamEncryption(args: StopDeliveryStreamEncryptionCommandInput, options?: __HttpHandlerOptions): Promise<StopDeliveryStreamEncryptionCommandOutput>;
312
68
  stopDeliveryStreamEncryption(args: StopDeliveryStreamEncryptionCommandInput, cb: (err: any, data?: StopDeliveryStreamEncryptionCommandOutput) => void): void;
313
69
  stopDeliveryStreamEncryption(args: StopDeliveryStreamEncryptionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StopDeliveryStreamEncryptionCommandOutput) => void): void;
314
70
  /**
315
- * @public
316
- * <p>Adds or updates tags for the specified delivery stream. A tag is a key-value pair
317
- * that you can define and assign to Amazon Web Services resources. If you specify a tag that
318
- * already exists, the tag value is replaced with the value that you specify in the request.
319
- * Tags are metadata. For example, you can add friendly names and descriptions or other types
320
- * of information that can help you distinguish the delivery stream. For more information
321
- * about tags, see <a href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html">Using Cost Allocation
322
- * Tags</a> in the <i>Amazon Web Services Billing and Cost Management User
323
- * Guide</i>. </p>
324
- * <p>Each delivery stream can have up to 50 tags. </p>
325
- * <p>This operation has a limit of five transactions per second per account. </p>
71
+ * @see {@link TagDeliveryStreamCommand}
326
72
  */
327
73
  tagDeliveryStream(args: TagDeliveryStreamCommandInput, options?: __HttpHandlerOptions): Promise<TagDeliveryStreamCommandOutput>;
328
74
  tagDeliveryStream(args: TagDeliveryStreamCommandInput, cb: (err: any, data?: TagDeliveryStreamCommandOutput) => void): void;
329
75
  tagDeliveryStream(args: TagDeliveryStreamCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TagDeliveryStreamCommandOutput) => void): void;
330
76
  /**
331
- * @public
332
- * <p>Removes tags from the specified delivery stream. Removed tags are deleted, and you
333
- * can't recover them after this operation successfully completes.</p>
334
- * <p>If you specify a tag that doesn't exist, the operation ignores it.</p>
335
- * <p>This operation has a limit of five transactions per second per account. </p>
77
+ * @see {@link UntagDeliveryStreamCommand}
336
78
  */
337
79
  untagDeliveryStream(args: UntagDeliveryStreamCommandInput, options?: __HttpHandlerOptions): Promise<UntagDeliveryStreamCommandOutput>;
338
80
  untagDeliveryStream(args: UntagDeliveryStreamCommandInput, cb: (err: any, data?: UntagDeliveryStreamCommandOutput) => void): void;
339
81
  untagDeliveryStream(args: UntagDeliveryStreamCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UntagDeliveryStreamCommandOutput) => void): void;
340
82
  /**
341
- * @public
342
- * <p>Updates the specified destination of the specified delivery stream.</p>
343
- *
344
- * <p>Use this operation to change the destination type (for example, to replace the Amazon
345
- * S3 destination with Amazon Redshift) or change the parameters associated with a destination
346
- * (for example, to change the bucket name of the Amazon S3 destination). The update might not
347
- * occur immediately. The target delivery stream remains active while the configurations are
348
- * updated, so data writes to the delivery stream can continue during this process. The
349
- * updated configurations are usually effective within a few minutes.</p>
350
- * <p>Switching between Amazon ES and other services is not supported. For an Amazon ES
351
- * destination, you can only update to another Amazon ES destination.</p>
352
- * <p>If the destination type is the same, Kinesis Data Firehose merges the configuration
353
- * parameters specified with the destination configuration that already exists on the delivery
354
- * stream. If any of the parameters are not specified in the call, the existing values are
355
- * retained. For example, in the Amazon S3 destination, if <a>EncryptionConfiguration</a> is not specified, then the existing
356
- * <code>EncryptionConfiguration</code> is maintained on the destination.</p>
357
- * <p>If the destination type is not the same, for example, changing the destination from
358
- * Amazon S3 to Amazon Redshift, Kinesis Data Firehose does not merge any parameters. In this
359
- * case, all parameters must be specified.</p>
360
- *
361
- * <p>Kinesis Data Firehose uses <code>CurrentDeliveryStreamVersionId</code> to avoid race
362
- * conditions and conflicting merges. This is a required field, and the service updates the
363
- * configuration only if the existing configuration has a version ID that matches. After the
364
- * update is applied successfully, the version ID is updated, and can be retrieved using <a>DescribeDeliveryStream</a>. Use the new version ID to set
365
- * <code>CurrentDeliveryStreamVersionId</code> in the next call.</p>
83
+ * @see {@link UpdateDestinationCommand}
366
84
  */
367
85
  updateDestination(args: UpdateDestinationCommandInput, options?: __HttpHandlerOptions): Promise<UpdateDestinationCommandOutput>;
368
86
  updateDestination(args: UpdateDestinationCommandInput, cb: (err: any, data?: UpdateDestinationCommandOutput) => void): void;
369
87
  updateDestination(args: UpdateDestinationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateDestinationCommandOutput) => void): void;
370
88
  }
89
+ /**
90
+ * @public
91
+ * <fullname>Amazon Kinesis Data Firehose API Reference</fullname>
92
+ * <p>Amazon Kinesis Data Firehose is a fully managed service that delivers real-time
93
+ * streaming data to destinations such as Amazon Simple Storage Service (Amazon S3), Amazon
94
+ * OpenSearch Service, Amazon Redshift, Splunk, and various other supportd
95
+ * destinations.</p>
96
+ */
97
+ export declare class Firehose extends FirehoseClient implements Firehose {
98
+ }
package/dist-types/ts3.4/Firehose.d.ts CHANGED
@@ -48,7 +48,7 @@ import {
48
48
  UpdateDestinationCommandOutput,
49
49
  } from "./commands/UpdateDestinationCommand";
50
50
  import { FirehoseClient } from "./FirehoseClient";
51
- export declare class Firehose extends FirehoseClient {
51
+ export interface Firehose {
52
52
  createDeliveryStream(
53
53
  args: CreateDeliveryStreamCommandInput,
54
54
  options?: __HttpHandlerOptions
@@ -206,3 +206,4 @@ export declare class Firehose extends FirehoseClient {
206
206
  cb: (err: any, data?: UpdateDestinationCommandOutput) => void
207
207
  ): void;
208
208
  }
209
+ export declare class Firehose extends FirehoseClient implements Firehose {}
package/package.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "@aws-sdk/client-firehose",
3
3
  "description": "AWS SDK for JavaScript Firehose Client for Node.js, Browser and React Native",
4
- "version": "3.315.0",
4
+ "version": "3.319.0",
5
5
  "scripts": {
6
6
  "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
7
7
  "build:cjs": "tsc -p tsconfig.cjs.json",
@@ -21,9 +21,9 @@
21
21
  "dependencies": {
22
22
  "@aws-crypto/sha256-browser": "3.0.0",
23
23
  "@aws-crypto/sha256-js": "3.0.0",
24
- "@aws-sdk/client-sts": "3.315.0",
24
+ "@aws-sdk/client-sts": "3.319.0",
25
25
  "@aws-sdk/config-resolver": "3.310.0",
26
- "@aws-sdk/credential-provider-node": "3.315.0",
26
+ "@aws-sdk/credential-provider-node": "3.319.0",
27
27
  "@aws-sdk/fetch-http-handler": "3.310.0",
28
28
  "@aws-sdk/hash-node": "3.310.0",
29
29
  "@aws-sdk/invalid-dependency": "3.310.0",
@@ -36,19 +36,19 @@
36
36
  "@aws-sdk/middleware-serde": "3.310.0",
37
37
  "@aws-sdk/middleware-signing": "3.310.0",
38
38
  "@aws-sdk/middleware-stack": "3.310.0",
39
- "@aws-sdk/middleware-user-agent": "3.310.0",
39
+ "@aws-sdk/middleware-user-agent": "3.319.0",
40
40
  "@aws-sdk/node-config-provider": "3.310.0",
41
41
  "@aws-sdk/node-http-handler": "3.310.0",
42
42
  "@aws-sdk/protocol-http": "3.310.0",
43
- "@aws-sdk/smithy-client": "3.315.0",
43
+ "@aws-sdk/smithy-client": "3.316.0",
44
44
  "@aws-sdk/types": "3.310.0",
45
45
  "@aws-sdk/url-parser": "3.310.0",
46
46
  "@aws-sdk/util-base64": "3.310.0",
47
47
  "@aws-sdk/util-body-length-browser": "3.310.0",
48
48
  "@aws-sdk/util-body-length-node": "3.310.0",
49
- "@aws-sdk/util-defaults-mode-browser": "3.315.0",
50
- "@aws-sdk/util-defaults-mode-node": "3.315.0",
51
- "@aws-sdk/util-endpoints": "3.310.0",
49
+ "@aws-sdk/util-defaults-mode-browser": "3.316.0",
50
+ "@aws-sdk/util-defaults-mode-node": "3.316.0",
51
+ "@aws-sdk/util-endpoints": "3.319.0",
52
52
  "@aws-sdk/util-retry": "3.310.0",
53
53
  "@aws-sdk/util-user-agent-browser": "3.310.0",
54
54
  "@aws-sdk/util-user-agent-node": "3.310.0",