agent-claw: automated task changes

cdk/node_modules/aws-cdk-lib/aws-kinesis/.jsiirc.json

@@ -0,0 +1,13 @@
+{
+  "targets": {
+    "java": {
+      "package": "software.amazon.awscdk.services.kinesis"
+    },
+    "dotnet": {
+      "namespace": "Amazon.CDK.AWS.Kinesis"
+    },
+    "python": {
+      "module": "aws_cdk.aws_kinesis"
+    }
+  }
+}

cdk/node_modules/aws-cdk-lib/aws-kinesis/README.md

@@ -0,0 +1,346 @@
+# Amazon Kinesis Construct Library
+
+
+[Amazon Kinesis](https://docs.aws.amazon.com/streams/latest/dev/introduction.html) provides collection and processing of large
+[streams](https://aws.amazon.com/streaming-data/) of data records in real time. Kinesis data streams can be used for rapid and continuous data
+intake and aggregation.
+
+## Table Of Contents
+
+- [Streams](#streams)
+  - [Encryption](#encryption)
+  - [Import](#import)
+  - [Permission Grants](#permission-grants)
+    - [Read Permissions](#read-permissions)
+    - [Write Permissions](#write-permissions)
+    - [Custom Permissions](#custom-permissions)
+  - [Metrics](#metrics)
+    - [Shard-level Metrics](#shard-level-metrics)
+- [Stream Consumers](#stream-consumers)
+  - [Read Permissions](#read-permissions-1)
+- [Resource Policy](#resource-policy)
+
+
+## Streams
+
+Amazon Kinesis Data Streams ingests a large amount of data in real time, durably stores the data, and makes the data available for consumption.
+
+Using the CDK, a new Kinesis stream can be created as part of the stack using the construct's constructor. You may specify the `streamName` to give
+your own identifier to the stream. If not, CloudFormation will generate a name.
+
+```ts
+new kinesis.Stream(this, 'MyFirstStream', {
+  streamName: 'my-awesome-stream',
+});
+```
+
+You can also specify properties such as `shardCount` to indicate how many shards the stream should choose and a `retentionPeriod`
+to specify how long the data in the shards should remain accessible.
+Read more at [Creating and Managing Streams](https://docs.aws.amazon.com/streams/latest/dev/working-with-streams.html)
+
+```ts
+new kinesis.Stream(this, 'MyFirstStream', {
+  streamName: 'my-awesome-stream',
+  shardCount: 3,
+  retentionPeriod: Duration.hours(48),
+});
+```
+
+### Encryption
+
+[Stream encryption](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-kinesis-stream-streamencryption.html) enables
+server-side encryption using an AWS KMS key for a specified stream.
+
+Encryption is enabled by default on your stream with the master key owned by Kinesis Data Streams in regions where it is supported.
+
+```ts
+new kinesis.Stream(this, 'MyEncryptedStream');
+```
+
+You can enable encryption on your stream with a user-managed key by specifying the `encryption` property.
+A KMS key will be created for you and associated with the stream.
+
+```ts
+new kinesis.Stream(this, 'MyEncryptedStream', {
+  encryption: kinesis.StreamEncryption.KMS,
+});
+```
+
+You can also supply your own external KMS key to use for stream encryption by specifying the `encryptionKey` property.
+
+```ts
+const key = new kms.Key(this, 'MyKey');
+
+new kinesis.Stream(this, 'MyEncryptedStream', {
+  encryption: kinesis.StreamEncryption.KMS,
+  encryptionKey: key,
+});
+```
+
+### Import
+
+Any Kinesis stream that has been created outside the stack can be imported into your CDK app.
+
+Streams can be imported by their ARN via the `Stream.fromStreamArn()` API
+
+```ts
+const importedStream = kinesis.Stream.fromStreamArn(this, 'ImportedStream',
+  'arn:aws:kinesis:us-east-2:123456789012:stream/f3j09j2230j',
+);
+```
+
+Encrypted Streams can also be imported by their attributes via the `Stream.fromStreamAttributes()` API
+
+```ts
+const importedStream = kinesis.Stream.fromStreamAttributes(this, 'ImportedEncryptedStream', {
+  streamArn: 'arn:aws:kinesis:us-east-2:123456789012:stream/f3j09j2230j',
+  encryptionKey: kms.Key.fromKeyArn(this, 'key',
+    'arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012',
+  ),
+});
+```
+
+### Permission Grants
+
+IAM roles, users or groups which need to be able to work with Amazon Kinesis streams at runtime should be granted IAM permissions.
+
+Any object that implements the `IGrantable` interface (has an associated principal) can be granted permissions by calling:
+
+- `grantRead(principal)` - grants the principal read access
+- `grantWrite(principal)` - grants the principal write permissions to a Stream
+- `grantReadWrite(principal)` - grants principal read and write permissions
+
+#### Read Permissions
+
+Grant `read` access to a stream by calling the `grantRead()` API.
+If the stream has an encryption key, read permissions will also be granted to the key.
+
+```ts
+const lambdaRole = new iam.Role(this, 'Role', {
+  assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),
+  description: 'Example role...',
+});
+
+const stream = new kinesis.Stream(this, 'MyEncryptedStream', {
+  encryption: kinesis.StreamEncryption.KMS,
+});
+
+// give lambda permissions to read stream
+stream.grantRead(lambdaRole);
+```
+
+The following read permissions are provided to a service principal by the `grantRead()` API:
+
+- `kinesis:DescribeStreamSummary`
+- `kinesis:GetRecords`
+- `kinesis:GetShardIterator`
+- `kinesis:ListShards`
+- `kinesis:SubscribeToShard`
+
+#### Write Permissions
+
+Grant `write` permissions to a stream is provided by calling the `grantWrite()` API.
+If the stream has an encryption key, write permissions will also be granted to the key.
+
+```ts
+const lambdaRole = new iam.Role(this, 'Role', {
+  assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),
+  description: 'Example role...',
+});
+
+const stream = new kinesis.Stream(this, 'MyEncryptedStream', {
+  encryption: kinesis.StreamEncryption.KMS,
+});
+
+// give lambda permissions to write to stream
+stream.grantWrite(lambdaRole);
+```
+
+The following write permissions are provided to a service principal by the `grantWrite()` API:
+
+- `kinesis:ListShards`
+- `kinesis:PutRecord`
+- `kinesis:PutRecords`
+
+#### Custom Permissions
+
+You can add any set of permissions to a stream by calling the `grant()` API.
+
+```ts
+const user = new iam.User(this, 'MyUser');
+
+const stream = new kinesis.Stream(this, 'MyStream');
+
+// give my user permissions to list shards
+stream.grant(user, 'kinesis:ListShards');
+```
+
+### Metrics
+
+You can use common metrics from your stream to create alarms and/or dashboards. The `stream.metric('MetricName')` method creates a metric with the stream namespace and dimension. You can also use pre-define methods like `stream.metricGetRecordsSuccess()`. To find out more about Kinesis metrics check [Monitoring the Amazon Kinesis Data Streams Service with Amazon CloudWatch](https://docs.aws.amazon.com/streams/latest/dev/monitoring-with-cloudwatch.html).
+
+```ts
+const stream = new kinesis.Stream(this, 'MyStream');
+
+// Using base metric method passing the metric name
+stream.metric('GetRecords.Success');
+
+// using pre-defined metric method
+stream.metricGetRecordsSuccess();
+
+// using pre-defined and overriding the statistic
+stream.metricGetRecordsSuccess({ statistic: 'Maximum' });
+```
+
+#### Shard-level Metrics
+
+You can enable enhanced shard-level metrics for your Kinesis stream to get detailed monitoring of individual shards. Shard-level metrics provide more granular insights into the performance and health of your stream.
+
+```ts
+const stream = new kinesis.Stream(this, 'MyStream', {
+  shardLevelMetrics: [kinesis.ShardLevelMetrics.ALL],
+});
+```
+
+You can also specify individual metrics that you want to monitor:
+
+```ts
+const stream = new kinesis.Stream(this, 'MyStream', {
+  shardLevelMetrics: [
+    kinesis.ShardLevelMetrics.INCOMING_BYTES,
+    kinesis.ShardLevelMetrics.INCOMING_RECORDS,
+    kinesis.ShardLevelMetrics.ITERATOR_AGE_MILLISECONDS,
+    kinesis.ShardLevelMetrics.OUTGOING_BYTES,
+    kinesis.ShardLevelMetrics.OUTGOING_RECORDS,
+    kinesis.ShardLevelMetrics.READ_PROVISIONED_THROUGHPUT_EXCEEDED,
+    kinesis.ShardLevelMetrics.WRITE_PROVISIONED_THROUGHPUT_EXCEEDED,
+  ],
+});
+```
+
+Available shard-level metrics include:
+
+- `INCOMING_BYTES` - The number of bytes successfully put to the shard
+- `INCOMING_RECORDS` - The number of records successfully put to the shard
+- `ITERATOR_AGE_MILLISECONDS` - The age of the last record in all GetRecords calls made against a shard
+- `OUTGOING_BYTES` - The number of bytes retrieved from the shard
+- `OUTGOING_RECORDS` - The number of records retrieved from the shard
+- `READ_PROVISIONED_THROUGHPUT_EXCEEDED` - The number of GetRecords calls throttled for the shard
+- `WRITE_PROVISIONED_THROUGHPUT_EXCEEDED` - The number of records rejected due to throttling for the shard
+- `ALL` - All available metrics
+
+Note: You cannot specify `ALL` together with other individual metrics. If you want all metrics, use `ALL` alone.
+
+For more information about shard-level metrics, see [Monitoring the Amazon Kinesis Data Streams Service with Amazon CloudWatch](https://docs.aws.amazon.com/streams/latest/dev/monitoring-with-cloudwatch.html#kinesis-metrics-shard).
+
+## Stream Consumers
+
+Creating stream consumers allow consumers to receive data from the stream using enhanced fan-out at a rate of up to 2 MiB per second for every shard.
+This rate is unaffected by the total number of consumers that read from the same stream.
+
+For more information, see [Develop enhanced fan-out consumers with dedicated throughput](https://docs.aws.amazon.com/streams/latest/dev/enhanced-consumers.html).
+
+To create and associate a stream consumer with a stream
+
+```ts
+const stream = new kinesis.Stream(this, 'MyStream');
+
+const streamConsumer = new kinesis.StreamConsumer(this, 'MyStreamConsumer', {
+  streamConsumerName: 'MyStreamConsumer',
+  stream,
+});
+```
+
+#### Read Permissions
+
+Grant `read` access to a stream consumer, and the stream it is registered with, by calling the `grantRead()` API.
+
+```ts
+const lambdaRole = new iam.Role(this, 'Role', {
+  assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),
+  description: 'Example role...',
+});
+
+const stream = new kinesis.Stream(this, 'MyEncryptedStream', {
+  encryption: kinesis.StreamEncryption.KMS,
+});
+const streamConsumer = new kinesis.StreamConsumer(this, 'MyStreamConsumer', {
+  streamConsumerName: 'MyStreamConsumer',
+  stream,
+});
+
+// give lambda permissions to read stream via the stream consumer
+streamConsumer.grantRead(lambdaRole);
+```
+
+In addition to stream's permissions, the following permissions are provided to a service principal by the `grantRead()` API:
+
+- `kinesis:DescribeStreamConsumer`,
+- `kinesis:SubscribeToShard`,
+
+## Resource Policy
+
+You can create a resource policy for a data stream or a stream consumer.
+For more information, see [Controlling access to Amazon Kinesis Data Streams resources using IAM](https://docs.aws.amazon.com/streams/latest/dev/controlling-access.html).
+
+A resource policy is automatically created when `addToResourcePolicy` is called, if one doesn't already exist.
+
+Using `addToResourcePolicy` is the simplest way to add a resource policy:
+
+```ts
+const stream = new kinesis.Stream(this, 'MyStream');
+const streamConsumer = new kinesis.StreamConsumer(this, 'MyStreamConsumer', {
+  streamConsumerName: 'MyStreamConsumer',
+  stream,
+});
+
+// create a stream resource policy via addToResourcePolicy method
+stream.addToResourcePolicy(new iam.PolicyStatement({
+  resources: [stream.streamArn],
+  actions: ['kinesis:GetRecords'],
+  principals: [new iam.AnyPrincipal()],
+}));
+
+// create a stream consumer resource policy via addToResourcePolicy method
+streamConsumer.addToResourcePolicy(new iam.PolicyStatement({
+  resources: [stream.streamArn],
+  actions: ['kinesis:DescribeStreamConsumer'],
+  principals: [new iam.AnyPrincipal()],
+}));
+```
+
+You can create a resource manually by using `ResourcePolicy`.
+Also, you can set a custom policy document to `ResourcePolicy`.
+If not, a blank policy document will be set.
+
+```ts
+const stream = new kinesis.Stream(this, 'MyStream');
+const streamConsumer = new kinesis.StreamConsumer(this, 'MyStreamConsumer', {
+  streamConsumerName: 'MyStreamConsumer',
+  stream,
+});
+
+// create a custom policy document
+const policyDocument = new iam.PolicyDocument({
+  assignSids: true,
+  statements: [
+    new iam.PolicyStatement({
+      actions: ['kinesis:GetRecords'],
+      resources: [stream.streamArn],
+      principals: [new iam.AnyPrincipal()],
+    }),
+  ],
+});
+
+// create a stream resource policy manually
+new kinesis.ResourcePolicy(this, 'ResourcePolicy', {
+  stream,
+  policyDocument,
+});
+
+// create a stream consumer resource policy manually
+new kinesis.ResourcePolicy(this, 'ResourcePolicy', {
+  streamConsumer,
+  policyDocument,
+});
+```

cdk/node_modules/aws-cdk-lib/aws-kinesis/index.d.ts

@@ -0,0 +1 @@
+export * from './lib';

cdk/node_modules/aws-cdk-lib/aws-kinesis/index.js

@@ -0,0 +1 @@
+"use strict";var __createBinding=exports&&exports.__createBinding||(Object.create?(function(o,m,k,k2){k2===void 0&&(k2=k);var desc=Object.getOwnPropertyDescriptor(m,k);(!desc||("get"in desc?!m.__esModule:desc.writable||desc.configurable))&&(desc={enumerable:!0,get:function(){return m[k]}}),Object.defineProperty(o,k2,desc)}):(function(o,m,k,k2){k2===void 0&&(k2=k),o[k2]=m[k]})),__exportStar=exports&&exports.__exportStar||function(m,exports2){for(var p in m)p!=="default"&&!Object.prototype.hasOwnProperty.call(exports2,p)&&__createBinding(exports2,m,p)};Object.defineProperty(exports,"__esModule",{value:!0});var _noFold;exports.ShardLevelMetrics=void 0,Object.defineProperty(exports,_noFold="ShardLevelMetrics",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").ShardLevelMetrics;return Object.defineProperty(exports,_noFold="ShardLevelMetrics",{enumerable:!0,configurable:!0,value}),value}}),exports.Stream=void 0,Object.defineProperty(exports,_noFold="Stream",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").Stream;return Object.defineProperty(exports,_noFold="Stream",{enumerable:!0,configurable:!0,value}),value}}),exports.StreamEncryption=void 0,Object.defineProperty(exports,_noFold="StreamEncryption",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").StreamEncryption;return Object.defineProperty(exports,_noFold="StreamEncryption",{enumerable:!0,configurable:!0,value}),value}}),exports.StreamMode=void 0,Object.defineProperty(exports,_noFold="StreamMode",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").StreamMode;return Object.defineProperty(exports,_noFold="StreamMode",{enumerable:!0,configurable:!0,value}),value}}),exports.StreamConsumer=void 0,Object.defineProperty(exports,_noFold="StreamConsumer",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").StreamConsumer;return Object.defineProperty(exports,_noFold="StreamConsumer",{enumerable:!0,configurable:!0,value}),value}}),exports.ResourcePolicy=void 0,Object.defineProperty(exports,_noFold="ResourcePolicy",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").ResourcePolicy;return Object.defineProperty(exports,_noFold="ResourcePolicy",{enumerable:!0,configurable:!0,value}),value}}),exports.CfnStream=void 0,Object.defineProperty(exports,_noFold="CfnStream",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").CfnStream;return Object.defineProperty(exports,_noFold="CfnStream",{enumerable:!0,configurable:!0,value}),value}}),exports.CfnStreamConsumer=void 0,Object.defineProperty(exports,_noFold="CfnStreamConsumer",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").CfnStreamConsumer;return Object.defineProperty(exports,_noFold="CfnStreamConsumer",{enumerable:!0,configurable:!0,value}),value}}),exports.CfnResourcePolicy=void 0,Object.defineProperty(exports,_noFold="CfnResourcePolicy",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").CfnResourcePolicy;return Object.defineProperty(exports,_noFold="CfnResourcePolicy",{enumerable:!0,configurable:!0,value}),value}});

cdk/node_modules/aws-cdk-lib/aws-kinesis/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './stream';
+export * from './stream-consumer';
+export * from './resource-policy';
+export * from './kinesis.generated';

cdk/node_modules/aws-cdk-lib/aws-kinesis/lib/index.js

@@ -0,0 +1 @@
+"use strict";var __createBinding=exports&&exports.__createBinding||(Object.create?(function(o,m,k,k2){k2===void 0&&(k2=k);var desc=Object.getOwnPropertyDescriptor(m,k);(!desc||("get"in desc?!m.__esModule:desc.writable||desc.configurable))&&(desc={enumerable:!0,get:function(){return m[k]}}),Object.defineProperty(o,k2,desc)}):(function(o,m,k,k2){k2===void 0&&(k2=k),o[k2]=m[k]})),__exportStar=exports&&exports.__exportStar||function(m,exports2){for(var p in m)p!=="default"&&!Object.prototype.hasOwnProperty.call(exports2,p)&&__createBinding(exports2,m,p)};Object.defineProperty(exports,"__esModule",{value:!0});var _noFold;exports.ShardLevelMetrics=void 0,Object.defineProperty(exports,_noFold="ShardLevelMetrics",{enumerable:!0,configurable:!0,get:()=>{var value=require("./stream").ShardLevelMetrics;return Object.defineProperty(exports,_noFold="ShardLevelMetrics",{enumerable:!0,configurable:!0,value}),value}}),exports.Stream=void 0,Object.defineProperty(exports,_noFold="Stream",{enumerable:!0,configurable:!0,get:()=>{var value=require("./stream").Stream;return Object.defineProperty(exports,_noFold="Stream",{enumerable:!0,configurable:!0,value}),value}}),exports.StreamEncryption=void 0,Object.defineProperty(exports,_noFold="StreamEncryption",{enumerable:!0,configurable:!0,get:()=>{var value=require("./stream").StreamEncryption;return Object.defineProperty(exports,_noFold="StreamEncryption",{enumerable:!0,configurable:!0,value}),value}}),exports.StreamMode=void 0,Object.defineProperty(exports,_noFold="StreamMode",{enumerable:!0,configurable:!0,get:()=>{var value=require("./stream").StreamMode;return Object.defineProperty(exports,_noFold="StreamMode",{enumerable:!0,configurable:!0,value}),value}}),exports.StreamConsumer=void 0,Object.defineProperty(exports,_noFold="StreamConsumer",{enumerable:!0,configurable:!0,get:()=>{var value=require("./stream-consumer").StreamConsumer;return Object.defineProperty(exports,_noFold="StreamConsumer",{enumerable:!0,configurable:!0,value}),value}}),exports.ResourcePolicy=void 0,Object.defineProperty(exports,_noFold="ResourcePolicy",{enumerable:!0,configurable:!0,get:()=>{var value=require("./resource-policy").ResourcePolicy;return Object.defineProperty(exports,_noFold="ResourcePolicy",{enumerable:!0,configurable:!0,value}),value}}),exports.CfnStream=void 0,Object.defineProperty(exports,_noFold="CfnStream",{enumerable:!0,configurable:!0,get:()=>{var value=require("./kinesis.generated").CfnStream;return Object.defineProperty(exports,_noFold="CfnStream",{enumerable:!0,configurable:!0,value}),value}}),exports.CfnStreamConsumer=void 0,Object.defineProperty(exports,_noFold="CfnStreamConsumer",{enumerable:!0,configurable:!0,get:()=>{var value=require("./kinesis.generated").CfnStreamConsumer;return Object.defineProperty(exports,_noFold="CfnStreamConsumer",{enumerable:!0,configurable:!0,value}),value}}),exports.CfnResourcePolicy=void 0,Object.defineProperty(exports,_noFold="CfnResourcePolicy",{enumerable:!0,configurable:!0,get:()=>{var value=require("./kinesis.generated").CfnResourcePolicy;return Object.defineProperty(exports,_noFold="CfnResourcePolicy",{enumerable:!0,configurable:!0,value}),value}});

cdk/node_modules/aws-cdk-lib/aws-kinesis/lib/kinesis-canned-metrics.generated.d.ts

@@ -0,0 +1,68 @@
+export interface MetricWithDims<D> {
+    readonly namespace: string;
+    readonly metricName: string;
+    readonly statistic: string;
+    readonly dimensionsMap: D;
+}
+export declare class KinesisMetrics {
+    static readProvisionedThroughputExceededSum(this: void, dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+    static writeProvisionedThroughputExceededSum(this: void, dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+    static getRecordsIteratorAgeMillisecondsMaximum(this: void, dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+    static putRecordSuccessSum(this: void, dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+    static putRecordsSuccessSum(this: void, dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+    static putRecordsBytesSum(this: void, dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+    static getRecordsSuccessSum(this: void, dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+    static getRecordsBytesSum(this: void, dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+    static getRecordsRecordsSum(this: void, dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+    static getRecordsLatencyMaximum(this: void, dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+    static incomingBytesSum(this: void, dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+    static incomingRecordsSum(this: void, dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+}

cdk/node_modules/aws-cdk-lib/aws-kinesis/lib/kinesis-canned-metrics.generated.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.KinesisMetrics=void 0;class KinesisMetrics{static readProvisionedThroughputExceededSum(dimensions){return{namespace:"AWS/Kinesis",metricName:"ReadProvisionedThroughputExceeded",dimensionsMap:dimensions,statistic:"Sum"}}static writeProvisionedThroughputExceededSum(dimensions){return{namespace:"AWS/Kinesis",metricName:"WriteProvisionedThroughputExceeded",dimensionsMap:dimensions,statistic:"Sum"}}static getRecordsIteratorAgeMillisecondsMaximum(dimensions){return{namespace:"AWS/Kinesis",metricName:"GetRecords.IteratorAgeMilliseconds",dimensionsMap:dimensions,statistic:"Maximum"}}static putRecordSuccessSum(dimensions){return{namespace:"AWS/Kinesis",metricName:"PutRecord.Success",dimensionsMap:dimensions,statistic:"Sum"}}static putRecordsSuccessSum(dimensions){return{namespace:"AWS/Kinesis",metricName:"PutRecords.Success",dimensionsMap:dimensions,statistic:"Sum"}}static putRecordsBytesSum(dimensions){return{namespace:"AWS/Kinesis",metricName:"PutRecords.Bytes",dimensionsMap:dimensions,statistic:"Sum"}}static getRecordsSuccessSum(dimensions){return{namespace:"AWS/Kinesis",metricName:"GetRecords.Success",dimensionsMap:dimensions,statistic:"Sum"}}static getRecordsBytesSum(dimensions){return{namespace:"AWS/Kinesis",metricName:"GetRecords.Bytes",dimensionsMap:dimensions,statistic:"Sum"}}static getRecordsRecordsSum(dimensions){return{namespace:"AWS/Kinesis",metricName:"GetRecords.Records",dimensionsMap:dimensions,statistic:"Sum"}}static getRecordsLatencyMaximum(dimensions){return{namespace:"AWS/Kinesis",metricName:"GetRecords.Latency",dimensionsMap:dimensions,statistic:"Maximum"}}static incomingBytesSum(dimensions){return{namespace:"AWS/Kinesis",metricName:"IncomingBytes",dimensionsMap:dimensions,statistic:"Sum"}}static incomingRecordsSum(dimensions){return{namespace:"AWS/Kinesis",metricName:"IncomingRecords",dimensionsMap:dimensions,statistic:"Sum"}}}exports.KinesisMetrics=KinesisMetrics;

cdk/node_modules/aws-cdk-lib/aws-kinesis/lib/kinesis-fixed-canned-metrics.d.ts

@@ -0,0 +1,195 @@
+/**
+ * This class is to consolidate all the metrics from Stream in just one place.
+ *
+ * Current generated canned metrics don't match the proper metrics from the service. If it is fixed
+ * at the source this class can be removed and just use the generated one directly.
+ *
+ * Stream Metrics reference: https://docs.aws.amazon.com/streams/latest/dev/monitoring-with-cloudwatch.html
+ */
+export declare class KinesisMetrics {
+    static getRecordsBytesAverage(this: void, dimensions: {
+        StreamName: string;
+    }): {
+        namespace: string;
+        metricName: string;
+        dimensionsMap: {
+            StreamName: string;
+        };
+        statistic: string;
+    };
+    static getRecordsSuccessAverage(this: void, dimensions: {
+        StreamName: string;
+    }): {
+        namespace: string;
+        metricName: string;
+        dimensionsMap: {
+            StreamName: string;
+        };
+        statistic: string;
+    };
+    static getRecordsRecordsAverage(this: void, dimensions: {
+        StreamName: string;
+    }): {
+        namespace: string;
+        metricName: string;
+        dimensionsMap: {
+            StreamName: string;
+        };
+        statistic: string;
+    };
+    static getRecordsLatencyAverage(this: void, dimensions: {
+        StreamName: string;
+    }): {
+        namespace: string;
+        metricName: string;
+        dimensionsMap: {
+            StreamName: string;
+        };
+        statistic: string;
+    };
+    static putRecordBytesAverage(this: void, dimensions: {
+        StreamName: string;
+    }): {
+        namespace: string;
+        metricName: string;
+        dimensionsMap: {
+            StreamName: string;
+        };
+        statistic: string;
+    };
+    static putRecordLatencyAverage(this: void, dimensions: {
+        StreamName: string;
+    }): {
+        namespace: string;
+        metricName: string;
+        dimensionsMap: {
+            StreamName: string;
+        };
+        statistic: string;
+    };
+    static getRecordsIteratorAgeMillisecondsMaximum(this: void, dimensions: {
+        StreamName: string;
+    }): import("./kinesis-canned-metrics.generated").MetricWithDims<{
+        StreamName: string;
+    }>;
+    static putRecordSuccessAverage(this: void, dimensions: {
+        StreamName: string;
+    }): {
+        statistic: string;
+        namespace: string;
+        metricName: string;
+        dimensionsMap: {
+            StreamName: string;
+        };
+    };
+    static putRecordsBytesAverage(this: void, dimensions: {
+        StreamName: string;
+    }): {
+        statistic: string;
+        namespace: string;
+        metricName: string;
+        dimensionsMap: {
+            StreamName: string;
+        };
+    };
+    static putRecordsLatencyAverage(this: void, dimensions: {
+        StreamName: string;
+    }): {
+        namespace: string;
+        metricName: string;
+        dimensionsMap: {
+            StreamName: string;
+        };
+        statistic: string;
+    };
+    static putRecordsSuccessAverage(this: void, dimensions: {
+        StreamName: string;
+    }): {
+        namespace: string;
+        metricName: string;
+        dimensionsMap: {
+            StreamName: string;
+        };
+        statistic: string;
+    };
+    static putRecordsTotalRecordsAverage(this: void, dimensions: {
+        StreamName: string;
+    }): {
+        namespace: string;
+        metricName: string;
+        dimensionsMap: {
+            StreamName: string;
+        };
+        statistic: string;
+    };
+    static putRecordsSuccessfulRecordsAverage(this: void, dimensions: {
+        StreamName: string;
+    }): {
+        namespace: string;
+        metricName: string;
+        dimensionsMap: {
+            StreamName: string;
+        };
+        statistic: string;
+    };
+    static putRecordsFailedRecordsAverage(this: void, dimensions: {
+        StreamName: string;
+    }): {
+        namespace: string;
+        metricName: string;
+        dimensionsMap: {
+            StreamName: string;
+        };
+        statistic: string;
+    };
+    static putRecordsThrottledRecordsAverage(this: void, dimensions: {
+        StreamName: string;
+    }): {
+        namespace: string;
+        metricName: string;
+        dimensionsMap: {
+            StreamName: string;
+        };
+        statistic: string;
+    };
+    static incomingBytesAverage(this: void, dimensions: {
+        StreamName: string;
+    }): {
+        statistic: string;
+        namespace: string;
+        metricName: string;
+        dimensionsMap: {
+            StreamName: string;
+        };
+    };
+    static incomingRecordsAverage(this: void, dimensions: {
+        StreamName: string;
+    }): {
+        statistic: string;
+        namespace: string;
+        metricName: string;
+        dimensionsMap: {
+            StreamName: string;
+        };
+    };
+    static readProvisionedThroughputExceededAverage(this: void, dimensions: {
+        StreamName: string;
+    }): {
+        statistic: string;
+        namespace: string;
+        metricName: string;
+        dimensionsMap: {
+            StreamName: string;
+        };
+    };
+    static writeProvisionedThroughputExceededAverage(this: void, dimensions: {
+        StreamName: string;
+    }): {
+        statistic: string;
+        namespace: string;
+        metricName: string;
+        dimensionsMap: {
+            StreamName: string;
+        };
+    };
+}

cdk/node_modules/aws-cdk-lib/aws-kinesis/lib/kinesis-fixed-canned-metrics.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.KinesisMetrics=void 0;var kinesis_canned_metrics_generated_1=()=>{var tmp=require("./kinesis-canned-metrics.generated");return kinesis_canned_metrics_generated_1=()=>tmp,tmp};class KinesisMetrics{static getRecordsBytesAverage(dimensions){return{namespace:"AWS/Kinesis",metricName:"GetRecords.Bytes",dimensionsMap:dimensions,statistic:"Average"}}static getRecordsSuccessAverage(dimensions){return{namespace:"AWS/Kinesis",metricName:"GetRecords.Success",dimensionsMap:dimensions,statistic:"Average"}}static getRecordsRecordsAverage(dimensions){return{namespace:"AWS/Kinesis",metricName:"GetRecords.Records",dimensionsMap:dimensions,statistic:"Average"}}static getRecordsLatencyAverage(dimensions){return{namespace:"AWS/Kinesis",metricName:"GetRecords.Latency",dimensionsMap:dimensions,statistic:"Average"}}static putRecordBytesAverage(dimensions){return{namespace:"AWS/Kinesis",metricName:"PutRecord.Bytes",dimensionsMap:dimensions,statistic:"Average"}}static putRecordLatencyAverage(dimensions){return{namespace:"AWS/Kinesis",metricName:"PutRecord.Latency",dimensionsMap:dimensions,statistic:"Average"}}static getRecordsIteratorAgeMillisecondsMaximum(dimensions){return kinesis_canned_metrics_generated_1().KinesisMetrics.getRecordsIteratorAgeMillisecondsMaximum(dimensions)}static putRecordSuccessAverage(dimensions){return{...kinesis_canned_metrics_generated_1().KinesisMetrics.putRecordSuccessSum(dimensions),statistic:"Average"}}static putRecordsBytesAverage(dimensions){return{...kinesis_canned_metrics_generated_1().KinesisMetrics.putRecordsBytesSum(dimensions),statistic:"Average"}}static putRecordsLatencyAverage(dimensions){return{namespace:"AWS/Kinesis",metricName:"PutRecords.Latency",dimensionsMap:dimensions,statistic:"Average"}}static putRecordsSuccessAverage(dimensions){return{namespace:"AWS/Kinesis",metricName:"PutRecords.Success",dimensionsMap:dimensions,statistic:"Average"}}static putRecordsTotalRecordsAverage(dimensions){return{namespace:"AWS/Kinesis",metricName:"PutRecords.TotalRecords",dimensionsMap:dimensions,statistic:"Average"}}static putRecordsSuccessfulRecordsAverage(dimensions){return{namespace:"AWS/Kinesis",metricName:"PutRecords.SuccessfulRecords",dimensionsMap:dimensions,statistic:"Average"}}static putRecordsFailedRecordsAverage(dimensions){return{namespace:"AWS/Kinesis",metricName:"PutRecords.FailedRecords",dimensionsMap:dimensions,statistic:"Average"}}static putRecordsThrottledRecordsAverage(dimensions){return{namespace:"AWS/Kinesis",metricName:"PutRecords.ThrottledRecords",dimensionsMap:dimensions,statistic:"Average"}}static incomingBytesAverage(dimensions){return{...kinesis_canned_metrics_generated_1().KinesisMetrics.incomingBytesSum(dimensions),statistic:"Average"}}static incomingRecordsAverage(dimensions){return{...kinesis_canned_metrics_generated_1().KinesisMetrics.incomingRecordsSum(dimensions),statistic:"Average"}}static readProvisionedThroughputExceededAverage(dimensions){return{...kinesis_canned_metrics_generated_1().KinesisMetrics.readProvisionedThroughputExceededSum(dimensions),statistic:"Average"}}static writeProvisionedThroughputExceededAverage(dimensions){return{...kinesis_canned_metrics_generated_1().KinesisMetrics.writeProvisionedThroughputExceededSum(dimensions),statistic:"Average"}}}exports.KinesisMetrics=KinesisMetrics;

cdk/node_modules/aws-cdk-lib/aws-kinesis/lib/kinesis.generated.d.ts

@@ -0,0 +1,605 @@
+import * as cdk from "../../core/lib";
+import * as constructs from "constructs";
+import * as cfn_parse from "../../core/lib/helpers-internal";
+import { IResourcePolicyRef, IStreamConsumerRef, IStreamRef, ResourcePolicyReference, StreamConsumerReference, StreamReference } from "../../interfaces/generated/aws-kinesis-interfaces.generated";
+import { aws_kinesis as kinesisRefs } from "../../interfaces";
+/**
+ * Creates a Kinesis stream that captures and transports data records that are emitted from data sources.
+ *
+ * For information about creating streams, see [CreateStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_CreateStream.html) in the Amazon Kinesis API Reference.
+ *
+ * @cloudformationResource AWS::Kinesis::Stream
+ * @stability external
+ * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-kinesis-stream.html
+ */
+export declare class CfnStream extends cdk.CfnResource implements cdk.IInspectable, IStreamRef, cdk.ITaggable {
+    /**
+     * The CloudFormation resource type name for this resource class.
+     */
+    static readonly CFN_RESOURCE_TYPE_NAME: string;
+    /**
+     * Build a CfnStream from CloudFormation properties
+     *
+     * A factory method that creates a new instance of this class from an object
+     * containing the CloudFormation properties of this resource.
+     * Used in the @aws-cdk/cloudformation-include module.
+     *
+     * @internal
+     */
+    static _fromCloudFormation(scope: constructs.Construct, id: string, resourceAttributes: any, options: cfn_parse.FromCloudFormationOptions): CfnStream;
+    /**
+     * Checks whether the given object is a CfnStream
+     */
+    static isCfnStream(x: any): x is CfnStream;
+    /**
+     * Creates a new IStreamRef from an ARN
+     */
+    static fromStreamArn(scope: constructs.Construct, id: string, arn: string): IStreamRef;
+    /**
+     * Creates a new IStreamRef from a streamName
+     */
+    static fromStreamName(scope: constructs.Construct, id: string, streamName: string): IStreamRef;
+    static arnForStream(resource: IStreamRef): string;
+    /**
+     * A list of shard-level metrics in properties to enable enhanced monitoring mode.
+     */
+    private _desiredShardLevelMetrics?;
+    /**
+     * The maximum record size of a single record in kibibyte (KiB) that you can write to, and read from a stream.
+     */
+    private _maxRecordSizeInKiB?;
+    /**
+     * The name of the Kinesis stream.
+     */
+    private _name?;
+    /**
+     * The number of hours for the data records that are stored in shards to remain accessible.
+     */
+    private _retentionPeriodHours?;
+    /**
+     * The number of shards that the stream uses.
+     */
+    private _shardCount?;
+    /**
+     * When specified, enables or updates server-side encryption using an AWS KMS key for a specified stream.
+     */
+    private _streamEncryption?;
+    /**
+     * Specifies the capacity mode to which you want to set your data stream.
+     */
+    private _streamModeDetails?;
+    /**
+     * Tag Manager which manages the tags for this resource
+     */
+    readonly tags: cdk.TagManager;
+    /**
+     * An arbitrary set of tags (key–value pairs) to associate with the Kinesis stream.
+     */
+    private _tagsRaw?;
+    /**
+     * The target warm throughput in MB/s that the stream should be scaled to handle.
+     */
+    private _warmThroughputMiBps?;
+    protected readonly cfnPropertyNames: Record<string, string>;
+    /**
+     * Create a new `AWS::Kinesis::Stream`.
+     *
+     * @param scope Scope in which this resource is defined
+     * @param id Construct identifier for this resource (unique in its scope)
+     * @param props Resource properties
+     */
+    constructor(scope: constructs.Construct, id: string, props?: CfnStreamProps);
+    get streamRef(): StreamReference;
+    /**
+     * A list of shard-level metrics in properties to enable enhanced monitoring mode.
+     */
+    get desiredShardLevelMetrics(): Array<string> | undefined;
+    /**
+     * A list of shard-level metrics in properties to enable enhanced monitoring mode.
+     */
+    set desiredShardLevelMetrics(value: Array<string> | undefined);
+    /**
+     * The maximum record size of a single record in kibibyte (KiB) that you can write to, and read from a stream.
+     */
+    get maxRecordSizeInKiB(): number | undefined;
+    /**
+     * The maximum record size of a single record in kibibyte (KiB) that you can write to, and read from a stream.
+     */
+    set maxRecordSizeInKiB(value: number | undefined);
+    /**
+     * The name of the Kinesis stream.
+     */
+    get name(): string | undefined;
+    /**
+     * The name of the Kinesis stream.
+     */
+    set name(value: string | undefined);
+    /**
+     * The number of hours for the data records that are stored in shards to remain accessible.
+     */
+    get retentionPeriodHours(): number | undefined;
+    /**
+     * The number of hours for the data records that are stored in shards to remain accessible.
+     */
+    set retentionPeriodHours(value: number | undefined);
+    /**
+     * The number of shards that the stream uses.
+     */
+    get shardCount(): number | undefined;
+    /**
+     * The number of shards that the stream uses.
+     */
+    set shardCount(value: number | undefined);
+    /**
+     * When specified, enables or updates server-side encryption using an AWS KMS key for a specified stream.
+     */
+    get streamEncryption(): cdk.IResolvable | CfnStream.StreamEncryptionProperty | undefined;
+    /**
+     * When specified, enables or updates server-side encryption using an AWS KMS key for a specified stream.
+     */
+    set streamEncryption(value: cdk.IResolvable | CfnStream.StreamEncryptionProperty | undefined);
+    /**
+     * Specifies the capacity mode to which you want to set your data stream.
+     */
+    get streamModeDetails(): cdk.IResolvable | CfnStream.StreamModeDetailsProperty | undefined;
+    /**
+     * Specifies the capacity mode to which you want to set your data stream.
+     */
+    set streamModeDetails(value: cdk.IResolvable | CfnStream.StreamModeDetailsProperty | undefined);
+    /**
+     * An arbitrary set of tags (key–value pairs) to associate with the Kinesis stream.
+     */
+    get tagsRaw(): Array<cdk.CfnTag> | undefined;
+    /**
+     * An arbitrary set of tags (key–value pairs) to associate with the Kinesis stream.
+     */
+    set tagsRaw(value: Array<cdk.CfnTag> | undefined);
+    /**
+     * The target warm throughput in MB/s that the stream should be scaled to handle.
+     */
+    get warmThroughputMiBps(): number | undefined;
+    /**
+     * The target warm throughput in MB/s that the stream should be scaled to handle.
+     */
+    set warmThroughputMiBps(value: number | undefined);
+    /**
+     * The Amazon resource name (ARN) of the Kinesis stream, such as `arn:aws:kinesis:us-east-2:123456789012:stream/mystream` .
+     *
+     * @cloudformationAttribute Arn
+     */
+    get attrArn(): string;
+    /**
+     * Warm throughput configuration details for the stream. Only present for ON_DEMAND streams.
+     *
+     * @cloudformationAttribute WarmThroughputObject
+     */
+    get attrWarmThroughputObject(): cdk.IResolvable;
+    protected get cfnProperties(): Record<string, any>;
+    /**
+     * Examines the CloudFormation resource and discloses attributes
+     *
+     * @param inspector tree inspector to collect and process attributes
+     */
+    inspect(inspector: cdk.TreeInspector): void;
+    protected renderProperties(props: Record<string, any>): Record<string, any>;
+}
+export declare namespace CfnStream {
+    /**
+     * Specifies the capacity mode to which you want to set your data stream.
+     *
+     * Currently, in Kinesis Data Streams, you can choose between an *on-demand* capacity mode and a *provisioned* capacity mode for your data streams.
+     *
+     * @struct
+     * @stability external
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-kinesis-stream-streammodedetails.html
+     */
+    interface StreamModeDetailsProperty {
+        /**
+         * Specifies the capacity mode to which you want to set your data stream.
+         *
+         * Currently, in Kinesis Data Streams, you can choose between an *on-demand* capacity mode and a *provisioned* capacity mode for your data streams.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-kinesis-stream-streammodedetails.html#cfn-kinesis-stream-streammodedetails-streammode
+         */
+        readonly streamMode: string;
+    }
+    /**
+     * Enables or updates server-side encryption using an AWS KMS key for a specified stream.
+     *
+     * > When invoking this API, you must use either the `StreamARN` or the `StreamName` parameter, or both. It is recommended that you use the `StreamARN` input parameter when you invoke this API.
+     *
+     * Starting encryption is an asynchronous operation. Upon receiving the request, Kinesis Data Streams returns immediately and sets the status of the stream to `UPDATING` . After the update is complete, Kinesis Data Streams sets the status of the stream back to `ACTIVE` . Updating or applying encryption normally takes a few seconds to complete, but it can take minutes. You can continue to read and write data to your stream while its status is `UPDATING` . Once the status of the stream is `ACTIVE` , encryption begins for records written to the stream.
+     *
+     * API Limits: You can successfully apply a new AWS KMS key for server-side encryption 25 times in a rolling 24-hour period.
+     *
+     * Note: It can take up to 5 seconds after the stream is in an `ACTIVE` status before all records written to the stream are encrypted. After you enable encryption, you can verify that encryption is applied by inspecting the API response from `PutRecord` or `PutRecords` .
+     *
+     * @struct
+     * @stability external
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-kinesis-stream-streamencryption.html
+     */
+    interface StreamEncryptionProperty {
+        /**
+         * The encryption type to use.
+         *
+         * The only valid value is `KMS` .
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-kinesis-stream-streamencryption.html#cfn-kinesis-stream-streamencryption-encryptiontype
+         */
+        readonly encryptionType: string;
+        /**
+         * The GUID for the customer-managed AWS KMS key to use for encryption.
+         *
+         * This value can be a globally unique identifier, a fully specified Amazon Resource Name (ARN) to either an alias or a key, or an alias name prefixed by "alias/".You can also use a master key owned by Kinesis Data Streams by specifying the alias `aws/kinesis` .
+         *
+         * - Key ARN example: `arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012`
+         * - Alias ARN example: `arn:aws:kms:us-east-1:123456789012:alias/MyAliasName`
+         * - Globally unique key ID example: `12345678-1234-1234-1234-123456789012`
+         * - Alias name example: `alias/MyAliasName`
+         * - Master key owned by Kinesis Data Streams: `alias/aws/kinesis`
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-kinesis-stream-streamencryption.html#cfn-kinesis-stream-streamencryption-keyid
+         */
+        readonly keyId: string;
+    }
+    /**
+     * Represents the warm throughput configuration on the stream.
+     *
+     * This is only present for On-Demand Kinesis Data Streams in accounts that have `MinimumThroughputBillingCommitment` enabled.
+     *
+     * @struct
+     * @stability external
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-kinesis-stream-warmthroughputobject.html
+     */
+    interface WarmThroughputObjectProperty {
+        /**
+         * The current warm throughput value on the stream.
+         *
+         * This is the write throughput in MiBps that the stream is currently scaled to handle.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-kinesis-stream-warmthroughputobject.html#cfn-kinesis-stream-warmthroughputobject-currentmibps
+         */
+        readonly currentMiBps?: number;
+        /**
+         * The target warm throughput value on the stream.
+         *
+         * This indicates that the stream is currently scaling towards this target value.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-kinesis-stream-warmthroughputobject.html#cfn-kinesis-stream-warmthroughputobject-targetmibps
+         */
+        readonly targetMiBps?: number;
+    }
+}
+/**
+ * Properties for defining a `CfnStream`
+ *
+ * @struct
+ * @stability external
+ * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-kinesis-stream.html
+ */
+export interface CfnStreamProps {
+    /**
+     * A list of shard-level metrics in properties to enable enhanced monitoring mode.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-kinesis-stream.html#cfn-kinesis-stream-desiredshardlevelmetrics
+     */
+    readonly desiredShardLevelMetrics?: Array<string>;
+    /**
+     * The maximum record size of a single record in kibibyte (KiB) that you can write to, and read from a stream.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-kinesis-stream.html#cfn-kinesis-stream-maxrecordsizeinkib
+     */
+    readonly maxRecordSizeInKiB?: number;
+    /**
+     * The name of the Kinesis stream.
+     *
+     * If you don't specify a name, AWS CloudFormation generates a unique physical ID and uses that ID for the stream name. For more information, see [Name Type](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html) .
+     *
+     * If you specify a name, you cannot perform updates that require replacement of this resource. You can perform updates that require no or some interruption. If you must replace the resource, specify a new name.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-kinesis-stream.html#cfn-kinesis-stream-name
+     */
+    readonly name?: string;
+    /**
+     * The number of hours for the data records that are stored in shards to remain accessible.
+     *
+     * The default value is 24. For more information about the stream retention period, see [Changing the Data Retention Period](https://docs.aws.amazon.com/streams/latest/dev/kinesis-extended-retention.html) in the Amazon Kinesis Developer Guide.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-kinesis-stream.html#cfn-kinesis-stream-retentionperiodhours
+     */
+    readonly retentionPeriodHours?: number;
+    /**
+     * The number of shards that the stream uses.
+     *
+     * For greater provisioned throughput, increase the number of shards.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-kinesis-stream.html#cfn-kinesis-stream-shardcount
+     */
+    readonly shardCount?: number;
+    /**
+     * When specified, enables or updates server-side encryption using an AWS KMS key for a specified stream.
+     *
+     * Removing this property from your stack template and updating your stack disables encryption.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-kinesis-stream.html#cfn-kinesis-stream-streamencryption
+     */
+    readonly streamEncryption?: cdk.IResolvable | CfnStream.StreamEncryptionProperty;
+    /**
+     * Specifies the capacity mode to which you want to set your data stream.
+     *
+     * Currently, in Kinesis Data Streams, you can choose between an *on-demand* capacity mode and a *provisioned* capacity mode for your data streams.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-kinesis-stream.html#cfn-kinesis-stream-streammodedetails
+     */
+    readonly streamModeDetails?: cdk.IResolvable | CfnStream.StreamModeDetailsProperty;
+    /**
+     * An arbitrary set of tags (key–value pairs) to associate with the Kinesis stream.
+     *
+     * For information about constraints for this property, see [Tag Restrictions](https://docs.aws.amazon.com/streams/latest/dev/tagging.html#tagging-restrictions) in the *Amazon Kinesis Developer Guide* .
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-kinesis-stream.html#cfn-kinesis-stream-tags
+     */
+    readonly tags?: Array<cdk.CfnTag>;
+    /**
+     * The target warm throughput in MB/s that the stream should be scaled to handle.
+     *
+     * This represents the throughput capacity that will be immediately available for write operations.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-kinesis-stream.html#cfn-kinesis-stream-warmthroughputmibps
+     */
+    readonly warmThroughputMiBps?: number;
+}
+/**
+ * Use the AWS CloudFormation `AWS::Kinesis::StreamConsumer` resource to register a consumer with a Kinesis data stream.
+ *
+ * The consumer you register can then call [SubscribeToShard](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_SubscribeToShard.html) to receive data from the stream using enhanced fan-out, at a rate of up to 2 MiB per second for every shard you subscribe to. This rate is unaffected by the total number of consumers that read from the same stream.
+ *
+ * You can register up to 20 consumers per stream. However, you can request a limit increase using the [Kinesis Data Streams limits form](https://docs.aws.amazon.com/support/v1?#/) . A given consumer can only be registered with one stream at a time.
+ *
+ * For more information, see [Using Consumers with Enhanced Fan-Out](https://docs.aws.amazon.com/streams/latest/dev/introduction-to-enhanced-consumers.html) .
+ *
+ * @cloudformationResource AWS::Kinesis::StreamConsumer
+ * @stability external
+ * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-kinesis-streamconsumer.html
+ */
+export declare class CfnStreamConsumer extends cdk.CfnResource implements cdk.IInspectable, IStreamConsumerRef, cdk.ITaggableV2 {
+    /**
+     * The CloudFormation resource type name for this resource class.
+     */
+    static readonly CFN_RESOURCE_TYPE_NAME: string;
+    /**
+     * Build a CfnStreamConsumer from CloudFormation properties
+     *
+     * A factory method that creates a new instance of this class from an object
+     * containing the CloudFormation properties of this resource.
+     * Used in the @aws-cdk/cloudformation-include module.
+     *
+     * @internal
+     */
+    static _fromCloudFormation(scope: constructs.Construct, id: string, resourceAttributes: any, options: cfn_parse.FromCloudFormationOptions): CfnStreamConsumer;
+    /**
+     * Checks whether the given object is a CfnStreamConsumer
+     */
+    static isCfnStreamConsumer(x: any): x is CfnStreamConsumer;
+    /**
+     * Tag Manager which manages the tags for this resource
+     */
+    readonly cdkTagManager: cdk.TagManager;
+    /**
+     * The name of the consumer is something you choose when you register the consumer.
+     */
+    private _consumerName;
+    /**
+     * The ARN of the stream with which you registered the consumer.
+     */
+    private _streamArn;
+    /**
+     * An array of tags to be added to a specified Kinesis resource.
+     */
+    private _tags?;
+    protected readonly cfnPropertyNames: Record<string, string>;
+    /**
+     * Create a new `AWS::Kinesis::StreamConsumer`.
+     *
+     * @param scope Scope in which this resource is defined
+     * @param id Construct identifier for this resource (unique in its scope)
+     * @param props Resource properties
+     */
+    constructor(scope: constructs.Construct, id: string, props: CfnStreamConsumerProps);
+    get streamConsumerRef(): StreamConsumerReference;
+    /**
+     * The name of the consumer is something you choose when you register the consumer.
+     */
+    get consumerName(): string;
+    /**
+     * The name of the consumer is something you choose when you register the consumer.
+     */
+    set consumerName(value: string);
+    /**
+     * The ARN of the stream with which you registered the consumer.
+     */
+    get streamArn(): string;
+    /**
+     * The ARN of the stream with which you registered the consumer.
+     */
+    set streamArn(value: string);
+    /**
+     * An array of tags to be added to a specified Kinesis resource.
+     */
+    get tags(): Array<cdk.CfnTag> | undefined;
+    /**
+     * An array of tags to be added to a specified Kinesis resource.
+     */
+    set tags(value: Array<cdk.CfnTag> | undefined);
+    /**
+     * When you register a consumer, Kinesis Data Streams generates an ARN for it. You need this ARN to be able to call [SubscribeToShard](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_SubscribeToShard.html) .
+     *
+     * If you delete a consumer and then create a new one with the same name, it won't have the same ARN. That's because consumer ARNs contain the creation timestamp. This is important to keep in mind if you have IAM policies that reference consumer ARNs.
+     *
+     * @cloudformationAttribute ConsumerARN
+     */
+    get attrConsumerArn(): string;
+    /**
+     * The time at which the consumer was created.
+     *
+     * @cloudformationAttribute ConsumerCreationTimestamp
+     */
+    get attrConsumerCreationTimestamp(): string;
+    /**
+     * The name you gave the consumer when you registered it.
+     *
+     * @cloudformationAttribute ConsumerName
+     */
+    get attrConsumerName(): string;
+    /**
+     * A consumer can't read data while in the `CREATING` or `DELETING` states.
+     *
+     * @cloudformationAttribute ConsumerStatus
+     */
+    get attrConsumerStatus(): string;
+    /**
+     * The ARN of the data stream with which the consumer is registered.
+     *
+     * @cloudformationAttribute StreamARN
+     */
+    get attrStreamArn(): string;
+    protected get cfnProperties(): Record<string, any>;
+    /**
+     * Examines the CloudFormation resource and discloses attributes
+     *
+     * @param inspector tree inspector to collect and process attributes
+     */
+    inspect(inspector: cdk.TreeInspector): void;
+    protected renderProperties(props: Record<string, any>): Record<string, any>;
+}
+/**
+ * Properties for defining a `CfnStreamConsumer`
+ *
+ * @struct
+ * @stability external
+ * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-kinesis-streamconsumer.html
+ */
+export interface CfnStreamConsumerProps {
+    /**
+     * The name of the consumer is something you choose when you register the consumer.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-kinesis-streamconsumer.html#cfn-kinesis-streamconsumer-consumername
+     */
+    readonly consumerName: string;
+    /**
+     * The ARN of the stream with which you registered the consumer.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-kinesis-streamconsumer.html#cfn-kinesis-streamconsumer-streamarn
+     */
+    readonly streamArn: string;
+    /**
+     * An array of tags to be added to a specified Kinesis resource.
+     *
+     * A tag consists of a required key and an optional value. You can specify up to 50 tag key-value pairs.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-kinesis-streamconsumer.html#cfn-kinesis-streamconsumer-tags
+     */
+    readonly tags?: Array<cdk.CfnTag>;
+}
+/**
+ * Attaches a resource-based policy to a data stream or registered consumer.
+ *
+ * If you are using an identity other than the root user of the AWS account that owns the resource, the calling identity must have the `PutResourcePolicy` permissions on the specified Kinesis Data Streams resource and belong to the owner's account in order to use this operation. If you don't have `PutResourcePolicy` permissions, Amazon Kinesis Data Streams returns a `403 Access Denied error` . If you receive a `ResourceNotFoundException` , check to see if you passed a valid stream or consumer resource.
+ *
+ * Request patterns can be one of the following:
+ *
+ * - Data stream pattern: `arn:aws.*:kinesis:.*:\d{12}:.*stream/\S+`
+ * - Consumer pattern: `^(arn):aws.*:kinesis:.*:\d{12}:.*stream\/[a-zA-Z0-9_.-]+\/consumer\/[a-zA-Z0-9_.-]+:[0-9]+`
+ *
+ * For more information, see [Controlling Access to Amazon Kinesis Data Streams Resources Using IAM](https://docs.aws.amazon.com/streams/latest/dev/controlling-access.html) .
+ *
+ * @cloudformationResource AWS::Kinesis::ResourcePolicy
+ * @stability external
+ * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-kinesis-resourcepolicy.html
+ */
+export declare class CfnResourcePolicy extends cdk.CfnResource implements cdk.IInspectable, IResourcePolicyRef {
+    /**
+     * The CloudFormation resource type name for this resource class.
+     */
+    static readonly CFN_RESOURCE_TYPE_NAME: string;
+    /**
+     * Build a CfnResourcePolicy from CloudFormation properties
+     *
+     * A factory method that creates a new instance of this class from an object
+     * containing the CloudFormation properties of this resource.
+     * Used in the @aws-cdk/cloudformation-include module.
+     *
+     * @internal
+     */
+    static _fromCloudFormation(scope: constructs.Construct, id: string, resourceAttributes: any, options: cfn_parse.FromCloudFormationOptions): CfnResourcePolicy;
+    /**
+     * Checks whether the given object is a CfnResourcePolicy
+     */
+    static isCfnResourcePolicy(x: any): x is CfnResourcePolicy;
+    /**
+     * Returns the Amazon Resource Name (ARN) of the resource-based policy.
+     */
+    private _resourceArn;
+    /**
+     * This is the description for the resource policy.
+     */
+    private _resourcePolicy;
+    protected readonly cfnPropertyNames: Record<string, string>;
+    /**
+     * Create a new `AWS::Kinesis::ResourcePolicy`.
+     *
+     * @param scope Scope in which this resource is defined
+     * @param id Construct identifier for this resource (unique in its scope)
+     * @param props Resource properties
+     */
+    constructor(scope: constructs.Construct, id: string, props: CfnResourcePolicyProps);
+    get resourcePolicyRef(): ResourcePolicyReference;
+    /**
+     * Returns the Amazon Resource Name (ARN) of the resource-based policy.
+     */
+    get resourceArn(): string;
+    /**
+     * Returns the Amazon Resource Name (ARN) of the resource-based policy.
+     */
+    set resourceArn(value: string);
+    /**
+     * This is the description for the resource policy.
+     */
+    get resourcePolicy(): any | cdk.IResolvable;
+    /**
+     * This is the description for the resource policy.
+     */
+    set resourcePolicy(value: any | cdk.IResolvable);
+    protected get cfnProperties(): Record<string, any>;
+    /**
+     * Examines the CloudFormation resource and discloses attributes
+     *
+     * @param inspector tree inspector to collect and process attributes
+     */
+    inspect(inspector: cdk.TreeInspector): void;
+    protected renderProperties(props: Record<string, any>): Record<string, any>;
+}
+/**
+ * Properties for defining a `CfnResourcePolicy`
+ *
+ * @struct
+ * @stability external
+ * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-kinesis-resourcepolicy.html
+ */
+export interface CfnResourcePolicyProps {
+    /**
+     * Returns the Amazon Resource Name (ARN) of the resource-based policy.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-kinesis-resourcepolicy.html#cfn-kinesis-resourcepolicy-resourcearn
+     */
+    readonly resourceArn: kinesisRefs.IStreamConsumerRef | kinesisRefs.IStreamRef | string;
+    /**
+     * This is the description for the resource policy.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-kinesis-resourcepolicy.html#cfn-kinesis-resourcepolicy-resourcepolicy
+     */
+    readonly resourcePolicy: any | cdk.IResolvable;
+}
+export type { IStreamRef, StreamReference };
+export type { IStreamConsumerRef, StreamConsumerReference };
+export type { IResourcePolicyRef, ResourcePolicyReference };

cdk/node_modules/aws-cdk-lib/aws-kinesis/lib/resource-policy.d.ts

@@ -0,0 +1,56 @@
+import type { Construct } from 'constructs';
+import type { IStream } from './stream';
+import type { IStreamConsumer } from './stream-consumer';
+import { PolicyDocument } from '../../aws-iam';
+import { Resource } from '../../core';
+/**
+ * Properties to associate a data stream with a policy
+ */
+export interface ResourcePolicyProps {
+    /**
+     * The stream this policy applies to.
+     *
+     * Note: only one of `stream` and `streamConsumer` must be set.
+     *
+     * @default - policy is not associated to a stream
+     */
+    readonly stream?: IStream;
+    /**
+     * The stream consumer this policy applies to.
+     *
+     * Note: only one of `stream` and `streamConsumer` must be set.
+     *
+     * @default - policy is not associated to a consumer
+     */
+    readonly streamConsumer?: IStreamConsumer;
+    /**
+     * IAM policy document to apply to a data stream.
+     *
+     * @default - empty policy document
+     */
+    readonly policyDocument?: PolicyDocument;
+}
+/**
+ * The policy for a data stream or registered consumer.
+ *
+ * Policies define the operations that are allowed on this resource.
+ *
+ * You almost never need to define this construct directly.
+ *
+ * All AWS resources that support resource policies have a method called
+ * `addToResourcePolicy()`, which will automatically create a new resource
+ * policy if one doesn't exist yet, otherwise it will add to the existing
+ * policy.
+ *
+ * Prefer to use `addToResourcePolicy()` instead.
+ */
+export declare class ResourcePolicy extends Resource {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * The IAM policy document for this policy.
+     */
+    readonly document: PolicyDocument;
+    constructor(scope: Construct, id: string, props: ResourcePolicyProps);
+    private createResourcePolicy;
+}

cdk/node_modules/aws-cdk-lib/aws-kinesis/lib/resource-policy.js

@@ -0,0 +1 @@
+"use strict";var __esDecorate=exports&&exports.__esDecorate||function(ctor,descriptorIn,decorators,contextIn,initializers,extraInitializers){function accept(f){if(f!==void 0&&typeof f!="function")throw new TypeError("Function expected");return f}for(var kind=contextIn.kind,key=kind==="getter"?"get":kind==="setter"?"set":"value",target=!descriptorIn&&ctor?contextIn.static?ctor:ctor.prototype:null,descriptor=descriptorIn||(target?Object.getOwnPropertyDescriptor(target,contextIn.name):{}),_,done=!1,i=decorators.length-1;i>=0;i--){var context={};for(var p in contextIn)context[p]=p==="access"?{}:contextIn[p];for(var p in contextIn.access)context.access[p]=contextIn.access[p];context.addInitializer=function(f){if(done)throw new TypeError("Cannot add initializers after decoration has completed");extraInitializers.push(accept(f||null))};var result=(0,decorators[i])(kind==="accessor"?{get:descriptor.get,set:descriptor.set}:descriptor[key],context);if(kind==="accessor"){if(result===void 0)continue;if(result===null||typeof result!="object")throw new TypeError("Object expected");(_=accept(result.get))&&(descriptor.get=_),(_=accept(result.set))&&(descriptor.set=_),(_=accept(result.init))&&initializers.unshift(_)}else(_=accept(result))&&(kind==="field"?initializers.unshift(_):descriptor[key]=_)}target&&Object.defineProperty(target,contextIn.name,descriptor),done=!0},__runInitializers=exports&&exports.__runInitializers||function(thisArg,initializers,value){for(var useValue=arguments.length>2,i=0;i<initializers.length;i++)value=useValue?initializers[i].call(thisArg,value):initializers[i].call(thisArg);return useValue?value:void 0};Object.defineProperty(exports,"__esModule",{value:!0}),exports.ResourcePolicy=void 0;var jsiiDeprecationWarnings=()=>{var tmp=require("../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var kinesis_generated_1=()=>{var tmp=require("./kinesis.generated");return kinesis_generated_1=()=>tmp,tmp},aws_iam_1=()=>{var tmp=require("../../aws-iam");return aws_iam_1=()=>tmp,tmp},core_1=()=>{var tmp=require("../../core");return core_1=()=>tmp,tmp},metadata_resource_1=()=>{var tmp=require("../../core/lib/metadata-resource");return metadata_resource_1=()=>tmp,tmp},literal_string_1=()=>{var tmp=require("../../core/lib/private/literal-string");return literal_string_1=()=>tmp,tmp},prop_injectable_1=()=>{var tmp=require("../../core/lib/prop-injectable");return prop_injectable_1=()=>tmp,tmp};let ResourcePolicy=(()=>{let _classDecorators=[prop_injectable_1().propertyInjectable],_classDescriptor,_classExtraInitializers=[],_classThis,_classSuper=core_1().Resource;var ResourcePolicy2=class extends _classSuper{static{_classThis=this}static{const _metadata=typeof Symbol=="function"&&Symbol.metadata?Object.create(_classSuper[Symbol.metadata]??null):void 0;__esDecorate(null,_classDescriptor={value:_classThis},_classDecorators,{kind:"class",name:_classThis.name,metadata:_metadata},null,_classExtraInitializers),ResourcePolicy2=_classThis=_classDescriptor.value,_metadata&&Object.defineProperty(_classThis,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:_metadata})}static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_kinesis.ResourcePolicy",version:"2.252.0"};static PROPERTY_INJECTION_ID="aws-cdk-lib.aws-kinesis.ResourcePolicy";document=new(aws_iam_1()).PolicyDocument;constructor(scope,id,props){super(scope,id);try{jsiiDeprecationWarnings().aws_cdk_lib_aws_kinesis_ResourcePolicyProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,ResourcePolicy2),error}if((0,metadata_resource_1().addConstructMetadata)(this,props),props.stream&&props.streamConsumer)throw new(core_1()).ValidationError((0,literal_string_1().lit)`OnlyOneStreamOrConsumer`,"Only one of stream or streamConsumer can be set",this);if(props.stream===void 0&&props.streamConsumer===void 0)throw new(core_1()).ValidationError((0,literal_string_1().lit)`OnlyOneStreamOrConsumer`,"One of stream or streamConsumer must be set",this);this.document=props.policyDocument??this.document,props.stream?this.createResourcePolicy(props.stream.streamArn):props.streamConsumer&&this.createResourcePolicy(props.streamConsumer.streamConsumerArn)}createResourcePolicy(resourceArn){return new(kinesis_generated_1()).CfnResourcePolicy(this,"Resource",{resourcePolicy:this.document,resourceArn})}static{__runInitializers(_classThis,_classExtraInitializers)}};return ResourcePolicy2=_classThis})();exports.ResourcePolicy=ResourcePolicy;

cdk/node_modules/aws-cdk-lib/aws-kinesis/lib/stream-consumer.d.ts

@@ -0,0 +1,154 @@
+import type { Construct } from 'constructs';
+import type { IStream } from './stream';
+import * as iam from '../../aws-iam';
+import type { IResource } from '../../core';
+import { Resource } from '../../core';
+import type { IStreamConsumerRef, StreamConsumerReference } from '../../interfaces/generated/aws-kinesis-interfaces.generated';
+/**
+ * A Kinesis Stream Consumer
+ */
+export interface IStreamConsumer extends IResource, IStreamConsumerRef {
+    /**
+     * The ARN of the stream consumer.
+     *
+     * @attribute
+     */
+    readonly streamConsumerArn: string;
+    /**
+     * The name of the stream consumer.
+     *
+     * @attribute
+     */
+    readonly streamConsumerName: string;
+    /**
+     * The stream associated with this consumer.
+     *
+     * @attribute
+     */
+    readonly stream: IStream;
+    /**
+     * Adds a statement to the IAM resource policy associated with this stream consumer.
+     *
+     * If this stream consumer was created in this stack (`new StreamConsumer`), a resource policy
+     * will be automatically created upon the first call to `addToResourcePolicy`. If
+     * the stream consumer is imported (`StreamConsumer.from`), then this is a no-op.
+     */
+    addToResourcePolicy(statement: iam.PolicyStatement): iam.AddToResourcePolicyResult;
+    /**
+     * Grant read permissions for this stream consumer and its associated stream to an IAM
+     * principal (Role/Group/User).
+     */
+    grantRead(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Grant the indicated permissions on this stream consumer to the provided IAM principal.
+     */
+    grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant;
+}
+declare abstract class StreamConsumerBase extends Resource implements IStreamConsumer {
+    /**
+     * The ARN of the stream consumer.
+     */
+    abstract readonly streamConsumerArn: string;
+    /**
+     * The name of the stream consumer.
+     */
+    abstract readonly streamConsumerName: string;
+    /**
+     * The Kinesis data stream this consumer is associated with.
+     */
+    abstract readonly stream: IStream;
+    /**
+     * A reference to this stream consumer.
+     */
+    get streamConsumerRef(): StreamConsumerReference;
+    /**
+     * Indicates if a resource policy should automatically be created upon
+     * the first call to `addToResourcePolicy`.
+     *
+     * Set by subclasses.
+     */
+    protected abstract readonly autoCreatePolicy: boolean;
+    private resourcePolicy?;
+    /**
+     * Adds a statement to the IAM resource policy associated with this stream consumer.
+     *
+     * If this stream consumer was created in this stack (`new StreamConsumer`), a resource policy
+     * will be automatically created upon the first call to `addToResourcePolicy`. If
+     * the stream is imported (`StreamConsumer.from`), then this is a no-op.
+     */
+    addToResourcePolicy(statement: iam.PolicyStatement): iam.AddToResourcePolicyResult;
+    /**
+     * Grant read permissions for this stream consumer and its associated stream to an IAM
+     * principal (Role/Group/User).
+     *
+     * [disable-awslint:no-grants]
+     */
+    grantRead(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Grant the indicated permissions on this stream consumer to the given IAM principal (Role/Group/User).
+     *
+     * [disable-awslint:no-grants]
+     */
+    grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant;
+}
+/**
+ * A reference to a StreamConsumer, which can be imported using `StreamConsumer.fromStreamConsumerAttributes`.
+ */
+export interface StreamConsumerAttributes {
+    /**
+     * The Amazon Resource Name (ARN) of the stream consumer.
+     */
+    readonly streamConsumerArn: string;
+}
+/**
+ * Properties for a Kinesis Stream Consumer.
+ */
+export interface StreamConsumerProps {
+    /**
+     * The name of the stream consumer.
+     */
+    readonly streamConsumerName: string;
+    /**
+     * The Kinesis data stream to associate this consumer with.
+     */
+    readonly stream: IStream;
+}
+/**
+ * A Kinesis Stream Consumer
+ */
+export declare class StreamConsumer extends StreamConsumerBase {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Imports an existing Kinesis Stream Consumer by its arn.
+     *
+     * @param scope the Construct scope.
+     * @param id the ID of the construct.
+     * @param streamConsumerArn the arn of the existing stream consumer.
+     */
+    static fromStreamConsumerArn(scope: Construct, id: string, streamConsumerArn: string): IStreamConsumer;
+    /**
+     * Imports an existing Kinesis Stream Consumer by its attributes.
+     *
+     * @param scope the Construct scope.
+     * @param id the ID of the construct.
+     * @param attrs the attributes of the existing stream consumer.
+     */
+    static fromStreamConsumerAttributes(scope: Construct, id: string, attrs: StreamConsumerAttributes): IStreamConsumer;
+    private readonly streamConsumer;
+    /**
+     * The Kinesis data stream this consumer is associated with.
+     */
+    readonly stream: IStream;
+    protected readonly autoCreatePolicy = true;
+    /**
+     * The Amazon Resource Name (ARN) of the stream consumer.
+     */
+    get streamConsumerArn(): string;
+    /**
+     * The name of the stream consumer.
+     */
+    get streamConsumerName(): string;
+    constructor(scope: Construct, id: string, props: StreamConsumerProps);
+}
+export {};

cdk/node_modules/aws-cdk-lib/aws-kinesis/lib/stream.d.ts

@@ -0,0 +1,712 @@
+import type { Construct } from 'constructs';
+import * as cloudwatch from '../../aws-cloudwatch';
+import * as iam from '../../aws-iam';
+import * as kms from '../../aws-kms';
+import type { Duration, IResource, RemovalPolicy, ResourceProps } from '../../core';
+import { Resource } from '../../core';
+import type { IStreamRef, StreamReference } from '../../interfaces/generated/aws-kinesis-interfaces.generated';
+/**
+ * Enhanced shard-level metrics
+ *
+ * @see https://docs.aws.amazon.com/streams/latest/dev/monitoring-with-cloudwatch.html#kinesis-metrics-shard
+ */
+export declare enum ShardLevelMetrics {
+    /**
+     * The number of bytes successfully put to the shard over the specified time period.
+     */
+    INCOMING_BYTES = "IncomingBytes",
+    /**
+     * The number of records successfully put to the shard over the specified time period.
+     */
+    INCOMING_RECORDS = "IncomingRecords",
+    /**
+     * The age of the last record in all GetRecords calls made against a shard, measured over the specified time period.
+     */
+    ITERATOR_AGE_MILLISECONDS = "IteratorAgeMilliseconds",
+    /**
+     * The number of bytes retrieved from the shard, measured over the specified time period.
+     */
+    OUTGOING_BYTES = "OutgoingBytes",
+    /**
+     * The number of records retrieved from the shard, measured over the specified time period.
+     */
+    OUTGOING_RECORDS = "OutgoingRecords",
+    /**
+     * The number of GetRecords calls throttled for the shard over the specified time period.
+     */
+    READ_PROVISIONED_THROUGHPUT_EXCEEDED = "ReadProvisionedThroughputExceeded",
+    /**
+     * The number of records rejected due to throttling for the shard over the specified time period.
+     */
+    WRITE_PROVISIONED_THROUGHPUT_EXCEEDED = "WriteProvisionedThroughputExceeded",
+    /**
+     * All metrics
+     */
+    ALL = "ALL"
+}
+/**
+ * A Kinesis Stream
+ */
+export interface IStream extends IResource, IStreamRef {
+    /**
+     * The ARN of the stream.
+     *
+     * @attribute
+     */
+    readonly streamArn: string;
+    /**
+     * The name of the stream
+     *
+     * @attribute
+     */
+    readonly streamName: string;
+    /**
+     * Optional KMS encryption key associated with this stream.
+     */
+    readonly encryptionKey?: kms.IKey;
+    /**
+     * Adds a statement to the IAM resource policy associated with this stream.
+     *
+     * If this stream was created in this stack (`new Stream`), a resource policy
+     * will be automatically created upon the first call to `addToResourcePolicy`. If
+     * the stream is imported (`Stream.import`), then this is a no-op.
+     */
+    addToResourcePolicy(statement: iam.PolicyStatement): iam.AddToResourcePolicyResult;
+    /**
+     * Grant read permissions for this stream and its contents to an IAM
+     * principal (Role/Group/User).
+     *
+     * If an encryption key is used, permission to ues the key to decrypt the
+     * contents of the stream will also be granted.
+     */
+    grantRead(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Grant write permissions for this stream and its contents to an IAM
+     * principal (Role/Group/User).
+     *
+     * If an encryption key is used, permission to ues the key to encrypt the
+     * contents of the stream will also be granted.
+     */
+    grantWrite(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Grants read/write permissions for this stream and its contents to an IAM
+     * principal (Role/Group/User).
+     *
+     * If an encryption key is used, permission to use the key for
+     * encrypt/decrypt will also be granted.
+     */
+    grantReadWrite(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Grant the indicated permissions on this stream to the provided IAM principal.
+     */
+    grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant;
+    /**
+     * Return stream metric based from its metric name
+     *
+     * @param metricName name of the stream metric
+     * @param props properties of the metric
+     */
+    metric(metricName: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of bytes retrieved from the Kinesis stream, measured over the specified time period. Minimum, Maximum,
+     * and Average statistics represent the bytes in a single GetRecords operation for the stream in the specified time
+     * period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricGetRecordsBytes(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The age of the last record in all GetRecords calls made against a Kinesis stream, measured over the specified time
+     * period. Age is the difference between the current time and when the last record of the GetRecords call was written
+     * to the stream. The Minimum and Maximum statistics can be used to track the progress of Kinesis consumer
+     * applications. A value of zero indicates that the records being read are completely caught up with the stream.
+     *
+     * The metric defaults to maximum over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricGetRecordsIteratorAgeMilliseconds(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The time taken per GetRecords operation, measured over the specified time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricGetRecordsLatency(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of records retrieved from the shard, measured over the specified time period. Minimum, Maximum, and
+     * Average statistics represent the records in a single GetRecords operation for the stream in the specified time
+     * period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricGetRecords(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of successful GetRecords operations per stream, measured over the specified time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricGetRecordsSuccess(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of bytes successfully put to the Kinesis stream over the specified time period. This metric includes
+     * bytes from PutRecord and PutRecords operations. Minimum, Maximum, and Average statistics represent the bytes in a
+     * single put operation for the stream in the specified time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricIncomingBytes(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of records successfully put to the Kinesis stream over the specified time period. This metric includes
+     * record counts from PutRecord and PutRecords operations. Minimum, Maximum, and Average statistics represent the
+     * records in a single put operation for the stream in the specified time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricIncomingRecords(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of bytes put to the Kinesis stream using the PutRecord operation over the specified time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricPutRecordBytes(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The time taken per PutRecord operation, measured over the specified time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricPutRecordLatency(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of successful PutRecord operations per Kinesis stream, measured over the specified time period. Average
+     * reflects the percentage of successful writes to a stream.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricPutRecordSuccess(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of bytes put to the Kinesis stream using the PutRecords operation over the specified time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricPutRecordsBytes(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The time taken per PutRecords operation, measured over the specified time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricPutRecordsLatency(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     *  The number of PutRecords operations where at least one record succeeded, per Kinesis stream, measured over the
+     *  specified time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricPutRecordsSuccess(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The total number of records sent in a PutRecords operation per Kinesis data stream, measured over the specified
+     * time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricPutRecordsTotalRecords(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of successful records in a PutRecords operation per Kinesis data stream, measured over the specified
+     * time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricPutRecordsSuccessfulRecords(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of records rejected due to internal failures in a PutRecords operation per Kinesis data stream,
+     * measured over the specified time period. Occasional internal failures are to be expected and should be retried.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricPutRecordsFailedRecords(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of records rejected due to throttling in a PutRecords operation per Kinesis data stream, measured over
+     * the specified time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricPutRecordsThrottledRecords(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of GetRecords calls throttled for the stream over the specified time period. The most commonly used
+     * statistic for this metric is Average.
+     *
+     * When the Minimum statistic has a value of 1, all records were throttled for the stream during the specified time
+     * period.
+     *
+     * When the Maximum statistic has a value of 0 (zero), no records were throttled for the stream during the specified
+     * time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties
+     *
+     * @param props properties of the metric
+     *
+     */
+    metricReadProvisionedThroughputExceeded(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of records rejected due to throttling for the stream over the specified time period. This metric
+     * includes throttling from PutRecord and PutRecords operations.
+     *
+     * When the Minimum statistic has a non-zero value, records were being throttled for the stream during the specified
+     * time period.
+     *
+     * When the Maximum statistic has a value of 0 (zero), no records were being throttled for the stream during the
+     * specified time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricWriteProvisionedThroughputExceeded(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+}
+/**
+ * A reference to a stream. The easiest way to instantiate is to call
+ * `stream.export()`. Then, the consumer can use `Stream.import(this, ref)` and
+ * get a `Stream`.
+ */
+export interface StreamAttributes {
+    /**
+     * The ARN of the stream.
+     */
+    readonly streamArn: string;
+    /**
+     * The KMS key securing the contents of the stream if encryption is enabled.
+     *
+     * @default - No encryption
+     */
+    readonly encryptionKey?: kms.IKey;
+}
+/**
+ * Represents a Kinesis Stream.
+ */
+declare abstract class StreamBase extends Resource implements IStream {
+    /**
+     * The ARN of the stream.
+     */
+    abstract readonly streamArn: string;
+    /**
+     * The name of the stream
+     */
+    abstract readonly streamName: string;
+    /**
+     * Optional KMS encryption key associated with this stream.
+     */
+    abstract readonly encryptionKey?: kms.IKey;
+    /**
+     * A reference to this stream.
+     */
+    get streamRef(): StreamReference;
+    /**
+     * Indicates if a stream resource policy should automatically be created upon
+     * the first call to `addToResourcePolicy`.
+     *
+     * Set by subclasses.
+     */
+    protected abstract readonly autoCreatePolicy: boolean;
+    private resourcePolicy?;
+    constructor(scope: Construct, id: string, props?: ResourceProps);
+    /**
+     * Adds a statement to the IAM resource policy associated with this stream.
+     *
+     * If this stream was created in this stack (`new Stream`), a resource policy
+     * will be automatically created upon the first call to `addToResourcePolicy`. If
+     * the stream is imported (`Stream.import`), then this is a no-op.
+     */
+    addToResourcePolicy(statement: iam.PolicyStatement): iam.AddToResourcePolicyResult;
+    /**
+     * Grant read permissions for this stream and its contents to an IAM
+     * principal (Role/Group/User).
+     *
+     * If an encryption key is used, permission to ues the key to decrypt the
+     * contents of the stream will also be granted.
+     *
+     * [disable-awslint:no-grants]
+     */
+    grantRead(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Grant write permissions for this stream and its contents to an IAM
+     * principal (Role/Group/User).
+     *
+     * If an encryption key is used, permission to ues the key to encrypt the
+     * contents of the stream will also be granted.
+     *
+     * [disable-awslint:no-grants]
+     */
+    grantWrite(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Grants read/write permissions for this stream and its contents to an IAM
+     * principal (Role/Group/User).
+     *
+     * If an encryption key is used, permission to use the key for
+     * encrypt/decrypt will also be granted.
+     *
+     * [disable-awslint:no-grants]
+     */
+    grantReadWrite(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Grant the indicated permissions on this stream to the given IAM principal (Role/Group/User).
+     *
+     * [disable-awslint:no-grants]
+     */
+    grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant;
+    /**
+     * Return stream metric based from its metric name
+     *
+     * @param metricName name of the stream metric
+     * @param props properties of the metric
+     */
+    metric(metricName: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of bytes retrieved from the Kinesis stream, measured over the specified time period. Minimum, Maximum,
+     * and Average statistics represent the bytes in a single GetRecords operation for the stream in the specified time
+     * period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricGetRecordsBytes(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The age of the last record in all GetRecords calls made against a Kinesis stream, measured over the specified time
+     * period. Age is the difference between the current time and when the last record of the GetRecords call was written
+     * to the stream. The Minimum and Maximum statistics can be used to track the progress of Kinesis consumer
+     * applications. A value of zero indicates that the records being read are completely caught up with the stream.
+     *
+     * The metric defaults to maximum over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricGetRecordsIteratorAgeMilliseconds(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of successful GetRecords operations per stream, measured over the specified time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricGetRecordsSuccess(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of records retrieved from the shard, measured over the specified time period. Minimum, Maximum, and
+     * Average statistics represent the records in a single GetRecords operation for the stream in the specified time
+     * period.
+     *
+     * average
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricGetRecords(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of successful GetRecords operations per stream, measured over the specified time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricGetRecordsLatency(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of bytes put to the Kinesis stream using the PutRecord operation over the specified time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricPutRecordBytes(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The time taken per PutRecord operation, measured over the specified time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricPutRecordLatency(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of successful PutRecord operations per Kinesis stream, measured over the specified time period. Average
+     * reflects the percentage of successful writes to a stream.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricPutRecordSuccess(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of bytes put to the Kinesis stream using the PutRecords operation over the specified time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricPutRecordsBytes(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The time taken per PutRecords operation, measured over the specified time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricPutRecordsLatency(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     *  The number of PutRecords operations where at least one record succeeded, per Kinesis stream, measured over the
+     *  specified time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricPutRecordsSuccess(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The total number of records sent in a PutRecords operation per Kinesis data stream, measured over the specified
+     * time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricPutRecordsTotalRecords(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of successful records in a PutRecords operation per Kinesis data stream, measured over the specified
+     * time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricPutRecordsSuccessfulRecords(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of records rejected due to internal failures in a PutRecords operation per Kinesis data stream,
+     * measured over the specified time period. Occasional internal failures are to be expected and should be retried.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricPutRecordsFailedRecords(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of records rejected due to throttling in a PutRecords operation per Kinesis data stream, measured over
+     * the specified time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricPutRecordsThrottledRecords(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of bytes successfully put to the Kinesis stream over the specified time period. This metric includes
+     * bytes from PutRecord and PutRecords operations. Minimum, Maximum, and Average statistics represent the bytes in a
+     * single put operation for the stream in the specified time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricIncomingBytes(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of records successfully put to the Kinesis stream over the specified time period. This metric includes
+     * record counts from PutRecord and PutRecords operations. Minimum, Maximum, and Average statistics represent the
+     * records in a single put operation for the stream in the specified time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricIncomingRecords(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of GetRecords calls throttled for the stream over the specified time period. The most commonly used
+     * statistic for this metric is Average.
+     *
+     * When the Minimum statistic has a value of 1, all records were throttled for the stream during the specified time
+     * period.
+     *
+     * When the Maximum statistic has a value of 0 (zero), no records were throttled for the stream during the specified
+     * time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties
+     *
+     * @param props properties of the metric
+     *
+     */
+    metricReadProvisionedThroughputExceeded(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of records rejected due to throttling for the stream over the specified time period. This metric
+     * includes throttling from PutRecord and PutRecords operations.
+     *
+     * When the Minimum statistic has a non-zero value, records were being throttled for the stream during the specified
+     * time period.
+     *
+     * When the Maximum statistic has a value of 0 (zero), no records were being throttled for the stream during the
+     * specified time period.
+     *
+     * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.
+     *
+     * @param props properties of the metric
+     */
+    metricWriteProvisionedThroughputExceeded(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    private metricFromCannedFunction;
+}
+/**
+ * Properties for a Kinesis Stream
+ */
+export interface StreamProps {
+    /**
+     * Enforces a particular physical stream name.
+     * @default <generated>
+     */
+    readonly streamName?: string;
+    /**
+     * The number of hours for the data records that are stored in shards to remain accessible.
+     * @default Duration.hours(24)
+     */
+    readonly retentionPeriod?: Duration;
+    /**
+     * The number of shards for the stream.
+     *
+     * Can only be provided if streamMode is Provisioned.
+     *
+     * @default 1
+     */
+    readonly shardCount?: number;
+    /**
+     * The kind of server-side encryption to apply to this stream.
+     *
+     * If you choose KMS, you can specify a KMS key via `encryptionKey`. If
+     * encryption key is not specified, a key will automatically be created.
+     *
+     * @default - StreamEncryption.KMS if encrypted Streams are supported in the region
+     *   or StreamEncryption.UNENCRYPTED otherwise.
+     *   StreamEncryption.KMS if an encryption key is supplied through the encryptionKey property
+     */
+    readonly encryption?: StreamEncryption;
+    /**
+     * External KMS key to use for stream encryption.
+     *
+     * The 'encryption' property must be set to "Kms".
+     *
+     * @default - Kinesis Data Streams master key ('/alias/aws/kinesis').
+     *   If encryption is set to StreamEncryption.KMS and this property is undefined, a new KMS key
+     *   will be created and associated with this stream.
+     */
+    readonly encryptionKey?: kms.IKey;
+    /**
+     * The capacity mode of this stream.
+     *
+     * @default StreamMode.PROVISIONED
+     */
+    readonly streamMode?: StreamMode;
+    /**
+     * Policy to apply when the stream is removed from the stack.
+     *
+     * @default RemovalPolicy.RETAIN
+     */
+    readonly removalPolicy?: RemovalPolicy;
+    /**
+     * A list of shard-level metrics in properties to enable enhanced monitoring mode.
+     *
+     * @see https://docs.aws.amazon.com/streams/latest/dev/monitoring-with-cloudwatch.html#kinesis-metrics-shard
+     *
+     * @default undefined - AWS Kinesis default is disabled
+     */
+    readonly shardLevelMetrics?: ShardLevelMetrics[];
+}
+/**
+ * A Kinesis stream. Can be encrypted with a KMS key.
+ */
+export declare class Stream extends StreamBase {
+    /**
+     * Uniquely identifies this class.
+     */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Import an existing Kinesis Stream provided an ARN
+     *
+     * @param scope The parent creating construct (usually `this`).
+     * @param id The construct's name
+     * @param streamArn Stream ARN (i.e. arn:aws:kinesis:<region>:<account-id>:stream/Foo)
+     */
+    static fromStreamArn(scope: Construct, id: string, streamArn: string): IStream;
+    /**
+     * Creates a Stream construct that represents an external stream.
+     *
+     * @param scope The parent creating construct (usually `this`).
+     * @param id The construct's name.
+     * @param attrs Stream import properties
+     */
+    static fromStreamAttributes(scope: Construct, id: string, attrs: StreamAttributes): IStream;
+    private readonly stream;
+    readonly encryptionKey?: kms.IKey;
+    protected readonly autoCreatePolicy = true;
+    get streamArn(): string;
+    get streamName(): string;
+    constructor(scope: Construct, id: string, props?: StreamProps);
+    /**
+     * Set up key properties and return the Stream encryption property from the
+     * user's configuration.
+     */
+    private parseEncryption;
+}
+/**
+ * What kind of server-side encryption to apply to this stream
+ */
+export declare enum StreamEncryption {
+    /**
+     * Records in the stream are not encrypted.
+     */
+    UNENCRYPTED = "NONE",
+    /**
+     * Server-side encryption with a KMS key managed by the user.
+     * If `encryptionKey` is specified, this key will be used, otherwise, one will be defined.
+     */
+    KMS = "KMS",
+    /**
+     * Server-side encryption with a master key managed by Amazon Kinesis
+     */
+    MANAGED = "MANAGED"
+}
+/**
+ * Specifies the capacity mode to apply to this stream.
+ */
+export declare enum StreamMode {
+    /**
+     * Specify the provisioned capacity mode. The stream will have `shardCount` shards unless
+     * modified and will be billed according to the provisioned capacity.
+     */
+    PROVISIONED = "PROVISIONED",
+    /**
+     * Specify the on-demand capacity mode. The stream will autoscale and be billed according to the
+     * volume of data ingested and retrieved.
+     */
+    ON_DEMAND = "ON_DEMAND"
+}
+export {};