terraconstructs 0.0.8

package/lib/aws/notify/kinesis-stream.js

@@ -0,0 +1,541 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamMode = exports.StreamEncryption = exports.Stream = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const arn_1 = require("../arn");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+const kinesis_fixed_canned_metrics_1 = require("./kinesis-fixed-canned-metrics");
+const resource_policy_1 = require("./resource-policy");
+const cloudwatch = require("../cloudwatch");
+const kms = require("../encryption");
+const iam = require("../iam");
+const READ_OPERATIONS = [
+    "kinesis:DescribeStreamSummary",
+    "kinesis:GetRecords",
+    "kinesis:GetShardIterator",
+    "kinesis:ListShards",
+    "kinesis:SubscribeToShard",
+    "kinesis:DescribeStream",
+    "kinesis:ListStreams",
+    "kinesis:DescribeStreamConsumer",
+];
+const WRITE_OPERATIONS = [
+    "kinesis:ListShards",
+    "kinesis:PutRecord",
+    "kinesis:PutRecords",
+];
+/**
+ * Represents a Kinesis Stream.
+ */
+class StreamBase extends aws_construct_1.AwsConstructBase {
+    get streamOutputs() {
+        return {
+            streamArn: this.streamArn,
+            streamName: this.streamName,
+        };
+    }
+    get outputs() {
+        return this.streamOutputs;
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.node.addValidation({
+            validate: () => this.resourcePolicy?.document.validateForResourcePolicy() ?? [],
+        });
+    }
+    /**
+     * Adds a statement to the IAM resource policy associated with this stream.
+     *
+     * If this stream was created in this stack (`new Strem`), 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) {
+        if (!this.resourcePolicy && this.autoCreatePolicy) {
+            this.resourcePolicy = new resource_policy_1.ResourcePolicy(this, "Policy", {
+                stream: this,
+            });
+        }
+        if (this.resourcePolicy) {
+            this.resourcePolicy.document.addStatements(statement);
+            return { statementAdded: true, policyDependable: this.resourcePolicy };
+        }
+        return { statementAdded: false };
+    }
+    /**
+     * 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) {
+        const ret = this.grant(grantee, ...READ_OPERATIONS);
+        if (this.encryptionKey) {
+            this.encryptionKey.grantDecrypt(grantee);
+        }
+        return ret;
+    }
+    /**
+     * 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) {
+        const ret = this.grant(grantee, ...WRITE_OPERATIONS);
+        // this.encryptionKey?.grantEncrypt(grantee);
+        return ret;
+    }
+    /**
+     * 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) {
+        const ret = this.grant(grantee, ...Array.from(new Set([...READ_OPERATIONS, ...WRITE_OPERATIONS])));
+        this.encryptionKey?.grantEncryptDecrypt(grantee);
+        return ret;
+    }
+    /**
+     * Grant the indicated permissions on this stream to the given IAM principal (Role/Group/User).
+     */
+    grant(grantee, ...actions) {
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions,
+            resourceArns: [this.streamArn],
+            scope: this,
+        });
+    }
+    /**
+     * Return stream metric based from its metric name
+     *
+     * @param metricName name of the stream metric
+     * @param props properties of the metric
+     */
+    metric(metricName, props) {
+        return new cloudwatch.Metric({
+            namespace: "AWS/Kinesis",
+            metricName,
+            dimensionsMap: {
+                StreamName: this.streamName,
+            },
+            ...props,
+        }).attachTo(this);
+    }
+    /**
+     * 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) {
+        return this.metricFromCannedFunction(kinesis_fixed_canned_metrics_1.KinesisMetrics.getRecordsBytesAverage, props);
+    }
+    /**
+     * 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) {
+        return this.metricFromCannedFunction(kinesis_fixed_canned_metrics_1.KinesisMetrics.getRecordsIteratorAgeMillisecondsMaximum, props);
+    }
+    /**
+     * 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) {
+        return this.metricFromCannedFunction(kinesis_fixed_canned_metrics_1.KinesisMetrics.getRecordsSuccessAverage, props);
+    }
+    /**
+     * 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) {
+        return this.metricFromCannedFunction(kinesis_fixed_canned_metrics_1.KinesisMetrics.getRecordsRecordsAverage, props);
+    }
+    /**
+     * 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) {
+        return this.metricFromCannedFunction(kinesis_fixed_canned_metrics_1.KinesisMetrics.getRecordsLatencyAverage, props);
+    }
+    /**
+     * 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) {
+        return this.metricFromCannedFunction(kinesis_fixed_canned_metrics_1.KinesisMetrics.putRecordBytesAverage, props);
+    }
+    /**
+     * 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) {
+        return this.metricFromCannedFunction(kinesis_fixed_canned_metrics_1.KinesisMetrics.putRecordLatencyAverage, props);
+    }
+    /**
+     * 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) {
+        return this.metricFromCannedFunction(kinesis_fixed_canned_metrics_1.KinesisMetrics.putRecordSuccessAverage, props);
+    }
+    /**
+     * 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) {
+        return this.metricFromCannedFunction(kinesis_fixed_canned_metrics_1.KinesisMetrics.putRecordsBytesAverage, props);
+    }
+    /**
+     * 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) {
+        return this.metricFromCannedFunction(kinesis_fixed_canned_metrics_1.KinesisMetrics.putRecordsLatencyAverage, props);
+    }
+    /**
+     *  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) {
+        return this.metricFromCannedFunction(kinesis_fixed_canned_metrics_1.KinesisMetrics.putRecordsSuccessAverage, props);
+    }
+    /**
+     * 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) {
+        return this.metricFromCannedFunction(kinesis_fixed_canned_metrics_1.KinesisMetrics.putRecordsTotalRecordsAverage, props);
+    }
+    /**
+     * 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) {
+        return this.metricFromCannedFunction(kinesis_fixed_canned_metrics_1.KinesisMetrics.putRecordsSuccessfulRecordsAverage, props);
+    }
+    /**
+     * 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) {
+        return this.metricFromCannedFunction(kinesis_fixed_canned_metrics_1.KinesisMetrics.putRecordsFailedRecordsAverage, props);
+    }
+    /**
+     * 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) {
+        return this.metricFromCannedFunction(kinesis_fixed_canned_metrics_1.KinesisMetrics.putRecordsThrottledRecordsAverage, props);
+    }
+    /**
+     * 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) {
+        return this.metricFromCannedFunction(kinesis_fixed_canned_metrics_1.KinesisMetrics.incomingBytesAverage, props);
+    }
+    /**
+     * 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) {
+        return this.metricFromCannedFunction(kinesis_fixed_canned_metrics_1.KinesisMetrics.incomingRecordsAverage, props);
+    }
+    /**
+     * 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) {
+        return this.metricFromCannedFunction(kinesis_fixed_canned_metrics_1.KinesisMetrics.readProvisionedThroughputExceededAverage, props);
+    }
+    /**
+     * 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) {
+        return this.metricFromCannedFunction(kinesis_fixed_canned_metrics_1.KinesisMetrics.writeProvisionedThroughputExceededAverage, props);
+    }
+    // create metrics based on generated KinesisMetrics static methods
+    metricFromCannedFunction(createCannedProps, props) {
+        return new cloudwatch.Metric({
+            ...createCannedProps({ StreamName: this.streamName }),
+            ...props,
+        }).attachTo(this);
+    }
+}
+/**
+ * A Kinesis stream. Can be encrypted with a KMS key.
+ *
+ * @resource aws_kinesis_stream
+ */
+class Stream extends StreamBase {
+    /**
+     * 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, id, streamArn) {
+        return Stream.fromStreamAttributes(scope, id, { streamArn });
+    }
+    /**
+     * 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, id, attrs) {
+        class Import extends StreamBase {
+            constructor() {
+                super(...arguments);
+                this.streamArn = attrs.streamArn;
+                this.streamName = aws_stack_1.AwsStack.ofAwsConstruct(scope).splitArn(attrs.streamArn, arn_1.ArnFormat.SLASH_RESOURCE_NAME).resourceName;
+                this.encryptionKey = attrs.encryptionKey;
+                this.autoCreatePolicy = false;
+            }
+        }
+        return new Import(scope, id, {
+            environmentFromArn: attrs.streamArn,
+        });
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.autoCreatePolicy = true;
+        const name = props.streamName ||
+            this.stack.uniqueResourceName(this, {
+                prefix: this.gridUUID,
+            });
+        let shardCount = props.shardCount;
+        const streamMode = props.streamMode;
+        if (streamMode === StreamMode.ON_DEMAND && shardCount !== undefined) {
+            throw new Error(`streamMode must be set to ${StreamMode.PROVISIONED} (default) when specifying shardCount`);
+        }
+        if ((streamMode === StreamMode.PROVISIONED || streamMode === undefined) &&
+            shardCount === undefined) {
+            shardCount = 1;
+        }
+        const retentionPeriodHours = props.retentionPeriod?.toHours() ?? 24;
+        if (!cdktf_1.Token.isUnresolved(retentionPeriodHours)) {
+            if (retentionPeriodHours < 24 || retentionPeriodHours > 8760) {
+                throw new Error(`retentionPeriod must be between 24 and 8760 hours. Received ${retentionPeriodHours}`);
+            }
+        }
+        const { streamEncryption, encryptionKey } = this.parseEncryption(props);
+        this.resource = new provider_aws_1.kinesisStream.KinesisStream(this, "Resource", {
+            name,
+            retentionPeriod: retentionPeriodHours,
+            shardCount,
+            ...streamEncryption,
+            ...(props.streamMode !== undefined
+                ? {
+                    streamModeDetails: { streamMode: props.streamMode },
+                }
+                : undefined),
+        });
+        this.streamArn = this.resource.arn;
+        this.streamName = this.resource.name;
+        this.encryptionKey = encryptionKey;
+    }
+    /**
+     * Set up key properties and return the Stream encryption property from the
+     * user's configuration.
+     */
+    parseEncryption(props) {
+        // if encryption properties are not set, default to KMS in regions where KMS is available
+        if (!props.encryption && !props.encryptionKey) {
+            const conditionName = "AwsCdkKinesisEncryptedStreamsUnsupportedRegions";
+            let unsupportedRegionCondition = this.stack.node.tryFindChild(conditionName);
+            const unsupportedRegions = ["cn-north-1", "cn-northwest-1"];
+            // create a single condition for the Stack
+            if (!unsupportedRegionCondition) {
+                unsupportedRegionCondition = new cdktf_1.TerraformLocal(this.stack, conditionName, cdktf_1.Fn.contains(unsupportedRegions, this.stack.region));
+            }
+            return {
+                streamEncryption: {
+                    encryptionType: conditionalString(unsupportedRegionCondition.expression, "KMS"),
+                    kmsKeyId: conditionalString(unsupportedRegionCondition.expression, "alias/aws/kinesis"),
+                },
+            };
+        }
+        // default based on whether encryption key is specified
+        const encryptionType = props.encryption ??
+            (props.encryptionKey
+                ? StreamEncryption.KMS
+                : StreamEncryption.UNENCRYPTED);
+        // if encryption key is set, encryption must be set to KMS.
+        if (encryptionType !== StreamEncryption.KMS && props.encryptionKey) {
+            throw new Error(`encryptionKey is specified, so 'encryption' must be set to KMS (value: ${encryptionType})`);
+        }
+        if (encryptionType === StreamEncryption.UNENCRYPTED) {
+            return {};
+        }
+        if (encryptionType === StreamEncryption.MANAGED) {
+            const encryption = {
+                encryptionType: "KMS",
+                kmsKeyId: "alias/aws/kinesis",
+            };
+            return { streamEncryption: encryption };
+        }
+        if (encryptionType === StreamEncryption.KMS) {
+            const encryptionKey = props.encryptionKey ||
+                new kms.Key(this, "Key", {
+                    description: `Created by ${this.node.path}`,
+                });
+            const streamEncryption = {
+                encryptionType: "KMS",
+                kmsKeyId: encryptionKey.keyArn,
+            };
+            return { encryptionKey, streamEncryption };
+        }
+        throw new Error(`Unexpected 'encryptionType': ${encryptionType}`);
+    }
+}
+exports.Stream = Stream;
+_a = JSII_RTTI_SYMBOL_1;
+Stream[_a] = { fqn: "terraconstructs.aws.notify.Stream", version: "0.0.8" };
+/**
+ * What kind of server-side encryption to apply to this stream
+ */
+var StreamEncryption;
+(function (StreamEncryption) {
+    /**
+     * Records in the stream are not encrypted.
+     */
+    StreamEncryption["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.
+     */
+    StreamEncryption["KMS"] = "KMS";
+    /**
+     * Server-side encryption with a master key managed by Amazon Kinesis
+     */
+    StreamEncryption["MANAGED"] = "MANAGED";
+})(StreamEncryption || (exports.StreamEncryption = StreamEncryption = {}));
+/**
+ * Specifies the capacity mode to apply to this stream.
+ */
+var StreamMode;
+(function (StreamMode) {
+    /**
+     * Specify the provisioned capacity mode. The stream will have `shardCount` shards unless
+     * modified and will be billed according to the provisioned capacity.
+     */
+    StreamMode["PROVISIONED"] = "PROVISIONED";
+    /**
+     * Specify the on-demand capacity mode. The stream will autoscale and be billed according to the
+     * volume of data ingested and retrieved.
+     */
+    StreamMode["ON_DEMAND"] = "ON_DEMAND";
+})(StreamMode || (exports.StreamMode = StreamMode = {}));
+/**
+ * Set string based on expression
+ *
+ * @param expression expression to evaluate
+ * @param value value to return if expression is true, otherwise null
+ */
+function conditionalString(expression, value) {
+    return cdktf_1.Token.asString(cdktf_1.Fn.conditional(expression, cdktf_1.Token.nullValue(), value));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"kinesis-stream.js","sourceRoot":"","sources":["../../../src/aws/notify/kinesis-stream.ts"],"names":[],"mappings":"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","sourcesContent":["import { kinesisStream } from \"@cdktf/provider-aws\";\nimport { Fn, Token, TerraformLocal } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { ArnFormat } from \"../arn\";\nimport {\n  IAwsConstruct,\n  AwsConstructBase,\n  AwsConstructProps,\n} from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport { KinesisMetrics } from \"./kinesis-fixed-canned-metrics\";\nimport { ResourcePolicy } from \"./resource-policy\";\nimport { Duration } from \"../../duration\";\nimport * as cloudwatch from \"../cloudwatch\";\nimport * as kms from \"../encryption\";\nimport * as iam from \"../iam\";\n\nconst READ_OPERATIONS = [\n  \"kinesis:DescribeStreamSummary\",\n  \"kinesis:GetRecords\",\n  \"kinesis:GetShardIterator\",\n  \"kinesis:ListShards\",\n  \"kinesis:SubscribeToShard\",\n  \"kinesis:DescribeStream\",\n  \"kinesis:ListStreams\",\n  \"kinesis:DescribeStreamConsumer\",\n];\n\nconst WRITE_OPERATIONS = [\n  \"kinesis:ListShards\",\n  \"kinesis:PutRecord\",\n  \"kinesis:PutRecords\",\n];\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface StreamOutputs {\n  /**\n   * The ARN of the stream.\n   *\n   * @attribute\n   */\n  readonly streamArn: string;\n\n  /**\n   * The name of the stream\n   *\n   * @attribute\n   */\n  readonly streamName: string;\n}\n\n/**\n * A Kinesis Stream\n */\nexport interface IStream extends IAwsConstruct {\n  /** Strongly typed outputs */\n  readonly streamOutputs: StreamOutputs;\n  /**\n   * The ARN of the stream.\n   *\n   * @attribute\n   */\n  readonly streamArn: string;\n\n  /**\n   * The name of the stream\n   *\n   * @attribute\n   */\n  readonly streamName: string;\n\n  /**\n   * Optional KMS encryption key associated with this stream.\n   */\n  readonly encryptionKey?: kms.IKey;\n\n  /**\n   * Adds a statement to the IAM resource policy associated with this stream.\n   *\n   * If this stream was created in this stack (`new Stream`), a resource policy\n   * will be automatically created upon the first call to `addToResourcePolicy`. If\n   * the stream is imported (`Stream.import`), then this is a no-op.\n   */\n  addToResourcePolicy(\n    statement: iam.PolicyStatement,\n  ): iam.AddToResourcePolicyResult;\n\n  /**\n   * Grant read permissions for this stream and its contents to an IAM\n   * principal (Role/Group/User).\n   *\n   * If an encryption key is used, permission to ues the key to decrypt the\n   * contents of the stream will also be granted.\n   */\n  grantRead(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grant write permissions for this stream and its contents to an IAM\n   * principal (Role/Group/User).\n   *\n   * If an encryption key is used, permission to ues the key to encrypt the\n   * contents of the stream will also be granted.\n   */\n  grantWrite(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grants read/write permissions for this stream and its contents to an IAM\n   * principal (Role/Group/User).\n   *\n   * If an encryption key is used, permission to use the key for\n   * encrypt/decrypt will also be granted.\n   */\n  grantReadWrite(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grant the indicated permissions on this stream to the provided IAM principal.\n   */\n  grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant;\n\n  /**\n   * Return stream metric based from its metric name\n   *\n   * @param metricName name of the stream metric\n   * @param props properties of the metric\n   */\n  metric(\n    metricName: string,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n\n  /**\n   * The number of bytes retrieved from the Kinesis stream, measured over the specified time period. Minimum, Maximum,\n   * and Average statistics represent the bytes in a single GetRecords operation for the stream in the specified time\n   * period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  metricGetRecordsBytes(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The age of the last record in all GetRecords calls made against a Kinesis stream, measured over the specified time\n   * period. Age is the difference between the current time and when the last record of the GetRecords call was written\n   * to the stream. The Minimum and Maximum statistics can be used to track the progress of Kinesis consumer\n   * applications. A value of zero indicates that the records being read are completely caught up with the stream.\n   *\n   * The metric defaults to maximum over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  metricGetRecordsIteratorAgeMilliseconds(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n\n  /**\n   * The time taken per GetRecords operation, measured over the specified time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  metricGetRecordsLatency(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of records retrieved from the shard, measured over the specified time period. Minimum, Maximum, and\n   * Average statistics represent the records in a single GetRecords operation for the stream in the specified time\n   * period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  metricGetRecords(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of successful GetRecords operations per stream, measured over the specified time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  metricGetRecordsSuccess(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of bytes successfully put to the Kinesis stream over the specified time period. This metric includes\n   * bytes from PutRecord and PutRecords operations. Minimum, Maximum, and Average statistics represent the bytes in a\n   * single put operation for the stream in the specified time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  metricIncomingBytes(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of records successfully put to the Kinesis stream over the specified time period. This metric includes\n   * record counts from PutRecord and PutRecords operations. Minimum, Maximum, and Average statistics represent the\n   * records in a single put operation for the stream in the specified time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  metricIncomingRecords(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of bytes put to the Kinesis stream using the PutRecord operation over the specified time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  metricPutRecordBytes(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The time taken per PutRecord operation, measured over the specified time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  metricPutRecordLatency(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of successful PutRecord operations per Kinesis stream, measured over the specified time period. Average\n   * reflects the percentage of successful writes to a stream.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  metricPutRecordSuccess(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of bytes put to the Kinesis stream using the PutRecords operation over the specified time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  metricPutRecordsBytes(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The time taken per PutRecords operation, measured over the specified time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  metricPutRecordsLatency(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   *  The number of PutRecords operations where at least one record succeeded, per Kinesis stream, measured over the\n   *  specified time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  metricPutRecordsSuccess(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The total number of records sent in a PutRecords operation per Kinesis data stream, measured over the specified\n   * time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  metricPutRecordsTotalRecords(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n\n  /**\n   * The number of successful records in a PutRecords operation per Kinesis data stream, measured over the specified\n   * time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  metricPutRecordsSuccessfulRecords(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n\n  /**\n   * The number of records rejected due to internal failures in a PutRecords operation per Kinesis data stream,\n   * measured over the specified time period. Occasional internal failures are to be expected and should be retried.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  metricPutRecordsFailedRecords(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n\n  /**\n   * The number of records rejected due to throttling in a PutRecords operation per Kinesis data stream, measured over\n   * the specified time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  metricPutRecordsThrottledRecords(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n\n  /**\n   * The number of GetRecords calls throttled for the stream over the specified time period. The most commonly used\n   * statistic for this metric is Average.\n   *\n   * When the Minimum statistic has a value of 1, all records were throttled for the stream during the specified time\n   * period.\n   *\n   * When the Maximum statistic has a value of 0 (zero), no records were throttled for the stream during the specified\n   * time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties\n   *\n   * @param props properties of the metric\n   *\n   */\n  metricReadProvisionedThroughputExceeded(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n\n  /**\n   * The number of records rejected due to throttling for the stream over the specified time period. This metric\n   * includes throttling from PutRecord and PutRecords operations.\n   *\n   * When the Minimum statistic has a non-zero value, records were being throttled for the stream during the specified\n   * time period.\n   *\n   * When the Maximum statistic has a value of 0 (zero), no records were being throttled for the stream during the\n   * specified time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  metricWriteProvisionedThroughputExceeded(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n}\n\n/**\n * A reference to a stream. The easiest way to instantiate is to call\n * `stream.export()`. Then, the consumer can use `Stream.import(this, ref)` and\n * get a `Stream`.\n */\nexport interface StreamAttributes {\n  /**\n   * The ARN of the stream.\n   */\n  readonly streamArn: string;\n\n  /**\n   * The KMS key securing the contents of the stream if encryption is enabled.\n   *\n   * @default - No encryption\n   */\n  readonly encryptionKey?: kms.IKey;\n}\n\n/**\n * Represents a Kinesis Stream.\n */\nabstract class StreamBase extends AwsConstructBase implements IStream {\n  /**\n   * The ARN of the stream.\n   */\n  public abstract readonly streamArn: string;\n\n  /**\n   * The name of the stream\n   */\n  public abstract readonly streamName: string;\n\n  public get streamOutputs(): StreamOutputs {\n    return {\n      streamArn: this.streamArn,\n      streamName: this.streamName,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.streamOutputs;\n  }\n\n  /**\n   * Optional KMS encryption key associated with this stream.\n   */\n  public abstract readonly encryptionKey?: kms.IKey;\n\n  /**\n   * Indicates if a stream resource policy should automatically be created upon\n   * the first call to `addToResourcePolicy`.\n   *\n   * Set by subclasses.\n   */\n  protected abstract readonly autoCreatePolicy: boolean;\n\n  private resourcePolicy?: ResourcePolicy;\n\n  constructor(scope: Construct, id: string, props: AwsConstructProps = {}) {\n    super(scope, id, props);\n\n    this.node.addValidation({\n      validate: () =>\n        this.resourcePolicy?.document.validateForResourcePolicy() ?? [],\n    });\n  }\n\n  /**\n   * Adds a statement to the IAM resource policy associated with this stream.\n   *\n   * If this stream was created in this stack (`new Strem`), a resource policy\n   * will be automatically created upon the first call to `addToResourcePolicy`. If\n   * the stream is imported (`Stream.import`), then this is a no-op.\n   */\n  public addToResourcePolicy(\n    statement: iam.PolicyStatement,\n  ): iam.AddToResourcePolicyResult {\n    if (!this.resourcePolicy && this.autoCreatePolicy) {\n      this.resourcePolicy = new ResourcePolicy(this, \"Policy\", {\n        stream: this,\n      });\n    }\n\n    if (this.resourcePolicy) {\n      this.resourcePolicy.document.addStatements(statement);\n      return { statementAdded: true, policyDependable: this.resourcePolicy };\n    }\n    return { statementAdded: false };\n  }\n\n  /**\n   * Grant read permissions for this stream and its contents to an IAM\n   * principal (Role/Group/User).\n   *\n   * If an encryption key is used, permission to ues the key to decrypt the\n   * contents of the stream will also be granted.\n   */\n  public grantRead(grantee: iam.IGrantable) {\n    const ret = this.grant(grantee, ...READ_OPERATIONS);\n\n    if (this.encryptionKey) {\n      this.encryptionKey.grantDecrypt(grantee);\n    }\n\n    return ret;\n  }\n\n  /**\n   * Grant write permissions for this stream and its contents to an IAM\n   * principal (Role/Group/User).\n   *\n   * If an encryption key is used, permission to ues the key to encrypt the\n   * contents of the stream will also be granted.\n   */\n  public grantWrite(grantee: iam.IGrantable) {\n    const ret = this.grant(grantee, ...WRITE_OPERATIONS);\n    // this.encryptionKey?.grantEncrypt(grantee);\n\n    return ret;\n  }\n\n  /**\n   * Grants read/write permissions for this stream and its contents to an IAM\n   * principal (Role/Group/User).\n   *\n   * If an encryption key is used, permission to use the key for\n   * encrypt/decrypt will also be granted.\n   */\n  public grantReadWrite(grantee: iam.IGrantable) {\n    const ret = this.grant(\n      grantee,\n      ...Array.from(new Set([...READ_OPERATIONS, ...WRITE_OPERATIONS])),\n    );\n    this.encryptionKey?.grantEncryptDecrypt(grantee);\n\n    return ret;\n  }\n\n  /**\n   * Grant the indicated permissions on this stream to the given IAM principal (Role/Group/User).\n   */\n  public grant(grantee: iam.IGrantable, ...actions: string[]) {\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions,\n      resourceArns: [this.streamArn],\n      scope: this,\n    });\n  }\n\n  /**\n   * Return stream metric based from its metric name\n   *\n   * @param metricName name of the stream metric\n   * @param props properties of the metric\n   */\n  public metric(metricName: string, props?: cloudwatch.MetricOptions) {\n    return new cloudwatch.Metric({\n      namespace: \"AWS/Kinesis\",\n      metricName,\n      dimensionsMap: {\n        StreamName: this.streamName,\n      },\n      ...props,\n    }).attachTo(this);\n  }\n\n  /**\n   * The number of bytes retrieved from the Kinesis stream, measured over the specified time period. Minimum, Maximum,\n   * and Average statistics represent the bytes in a single GetRecords operation for the stream in the specified time\n   * period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  public metricGetRecordsBytes(props?: cloudwatch.MetricOptions) {\n    return this.metricFromCannedFunction(\n      KinesisMetrics.getRecordsBytesAverage,\n      props,\n    );\n  }\n\n  /**\n   * The age of the last record in all GetRecords calls made against a Kinesis stream, measured over the specified time\n   * period. Age is the difference between the current time and when the last record of the GetRecords call was written\n   * to the stream. The Minimum and Maximum statistics can be used to track the progress of Kinesis consumer\n   * applications. A value of zero indicates that the records being read are completely caught up with the stream.\n   *\n   * The metric defaults to maximum over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  public metricGetRecordsIteratorAgeMilliseconds(\n    props?: cloudwatch.MetricOptions,\n  ) {\n    return this.metricFromCannedFunction(\n      KinesisMetrics.getRecordsIteratorAgeMillisecondsMaximum,\n      props,\n    );\n  }\n\n  /**\n   * The number of successful GetRecords operations per stream, measured over the specified time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  public metricGetRecordsSuccess(props?: cloudwatch.MetricOptions) {\n    return this.metricFromCannedFunction(\n      KinesisMetrics.getRecordsSuccessAverage,\n      props,\n    );\n  }\n\n  /**\n   * The number of records retrieved from the shard, measured over the specified time period. Minimum, Maximum, and\n   * Average statistics represent the records in a single GetRecords operation for the stream in the specified time\n   * period.\n   *\n   * average\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  public metricGetRecords(props?: cloudwatch.MetricOptions) {\n    return this.metricFromCannedFunction(\n      KinesisMetrics.getRecordsRecordsAverage,\n      props,\n    );\n  }\n\n  /**\n   * The number of successful GetRecords operations per stream, measured over the specified time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  public metricGetRecordsLatency(props?: cloudwatch.MetricOptions) {\n    return this.metricFromCannedFunction(\n      KinesisMetrics.getRecordsLatencyAverage,\n      props,\n    );\n  }\n\n  /**\n   * The number of bytes put to the Kinesis stream using the PutRecord operation over the specified time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  public metricPutRecordBytes(props?: cloudwatch.MetricOptions) {\n    return this.metricFromCannedFunction(\n      KinesisMetrics.putRecordBytesAverage,\n      props,\n    );\n  }\n\n  /**\n   * The time taken per PutRecord operation, measured over the specified time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  metricPutRecordLatency(props?: cloudwatch.MetricOptions) {\n    return this.metricFromCannedFunction(\n      KinesisMetrics.putRecordLatencyAverage,\n      props,\n    );\n  }\n\n  /**\n   * The number of successful PutRecord operations per Kinesis stream, measured over the specified time period. Average\n   * reflects the percentage of successful writes to a stream.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  public metricPutRecordSuccess(props?: cloudwatch.MetricOptions) {\n    return this.metricFromCannedFunction(\n      KinesisMetrics.putRecordSuccessAverage,\n      props,\n    );\n  }\n\n  /**\n   * The number of bytes put to the Kinesis stream using the PutRecords operation over the specified time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  public metricPutRecordsBytes(props?: cloudwatch.MetricOptions) {\n    return this.metricFromCannedFunction(\n      KinesisMetrics.putRecordsBytesAverage,\n      props,\n    );\n  }\n\n  /**\n   * The time taken per PutRecords operation, measured over the specified time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  public metricPutRecordsLatency(props?: cloudwatch.MetricOptions) {\n    return this.metricFromCannedFunction(\n      KinesisMetrics.putRecordsLatencyAverage,\n      props,\n    );\n  }\n\n  /**\n   *  The number of PutRecords operations where at least one record succeeded, per Kinesis stream, measured over the\n   *  specified time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  public metricPutRecordsSuccess(props?: cloudwatch.MetricOptions) {\n    return this.metricFromCannedFunction(\n      KinesisMetrics.putRecordsSuccessAverage,\n      props,\n    );\n  }\n\n  /**\n   * The total number of records sent in a PutRecords operation per Kinesis data stream, measured over the specified\n   * time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  public metricPutRecordsTotalRecords(props?: cloudwatch.MetricOptions) {\n    return this.metricFromCannedFunction(\n      KinesisMetrics.putRecordsTotalRecordsAverage,\n      props,\n    );\n  }\n\n  /**\n   * The number of successful records in a PutRecords operation per Kinesis data stream, measured over the specified\n   * time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  public metricPutRecordsSuccessfulRecords(props?: cloudwatch.MetricOptions) {\n    return this.metricFromCannedFunction(\n      KinesisMetrics.putRecordsSuccessfulRecordsAverage,\n      props,\n    );\n  }\n\n  /**\n   * The number of records rejected due to internal failures in a PutRecords operation per Kinesis data stream,\n   * measured over the specified time period. Occasional internal failures are to be expected and should be retried.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  public metricPutRecordsFailedRecords(props?: cloudwatch.MetricOptions) {\n    return this.metricFromCannedFunction(\n      KinesisMetrics.putRecordsFailedRecordsAverage,\n      props,\n    );\n  }\n\n  /**\n   * The number of records rejected due to throttling in a PutRecords operation per Kinesis data stream, measured over\n   * the specified time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  public metricPutRecordsThrottledRecords(props?: cloudwatch.MetricOptions) {\n    return this.metricFromCannedFunction(\n      KinesisMetrics.putRecordsThrottledRecordsAverage,\n      props,\n    );\n  }\n\n  /**\n   * The number of bytes successfully put to the Kinesis stream over the specified time period. This metric includes\n   * bytes from PutRecord and PutRecords operations. Minimum, Maximum, and Average statistics represent the bytes in a\n   * single put operation for the stream in the specified time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  public metricIncomingBytes(props?: cloudwatch.MetricOptions) {\n    return this.metricFromCannedFunction(\n      KinesisMetrics.incomingBytesAverage,\n      props,\n    );\n  }\n\n  /**\n   * The number of records successfully put to the Kinesis stream over the specified time period. This metric includes\n   * record counts from PutRecord and PutRecords operations. Minimum, Maximum, and Average statistics represent the\n   * records in a single put operation for the stream in the specified time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  public metricIncomingRecords(props?: cloudwatch.MetricOptions) {\n    return this.metricFromCannedFunction(\n      KinesisMetrics.incomingRecordsAverage,\n      props,\n    );\n  }\n\n  /**\n   * The number of GetRecords calls throttled for the stream over the specified time period. The most commonly used\n   * statistic for this metric is Average.\n   *\n   * When the Minimum statistic has a value of 1, all records were throttled for the stream during the specified time\n   * period.\n   *\n   * When the Maximum statistic has a value of 0 (zero), no records were throttled for the stream during the specified\n   * time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties\n   *\n   * @param props properties of the metric\n   *\n   */\n  public metricReadProvisionedThroughputExceeded(\n    props?: cloudwatch.MetricOptions,\n  ) {\n    return this.metricFromCannedFunction(\n      KinesisMetrics.readProvisionedThroughputExceededAverage,\n      props,\n    );\n  }\n\n  /**\n   * The number of records rejected due to throttling for the stream over the specified time period. This metric\n   * includes throttling from PutRecord and PutRecords operations.\n   *\n   * When the Minimum statistic has a non-zero value, records were being throttled for the stream during the specified\n   * time period.\n   *\n   * When the Maximum statistic has a value of 0 (zero), no records were being throttled for the stream during the\n   * specified time period.\n   *\n   * The metric defaults to average over 5 minutes, it can be changed by passing `statistic` and `period` properties.\n   *\n   * @param props properties of the metric\n   */\n  public metricWriteProvisionedThroughputExceeded(\n    props?: cloudwatch.MetricOptions,\n  ) {\n    return this.metricFromCannedFunction(\n      KinesisMetrics.writeProvisionedThroughputExceededAverage,\n      props,\n    );\n  }\n\n  // create metrics based on generated KinesisMetrics static methods\n  private metricFromCannedFunction(\n    createCannedProps: (dimensions: {\n      StreamName: string;\n    }) => cloudwatch.MetricProps,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      ...createCannedProps({ StreamName: this.streamName }),\n      ...props,\n    }).attachTo(this);\n  }\n}\n\n/**\n * Properties for a Kinesis Stream\n */\nexport interface StreamProps extends AwsConstructProps {\n  /**\n   * Enforces a particular physical stream name.\n   * @default <generated>\n   */\n  readonly streamName?: string;\n\n  /**\n   * The number of hours for the data records that are stored in shards to remain accessible.\n   * @default Duration.hours(24)\n   */\n  readonly retentionPeriod?: Duration;\n\n  /**\n   * The number of shards for the stream.\n   *\n   * Can only be provided if streamMode is Provisioned.\n   *\n   * @default 1\n   */\n  readonly shardCount?: number;\n\n  /**\n   * The kind of server-side encryption to apply to this stream.\n   *\n   * If you choose KMS, you can specify a KMS key via `encryptionKey`. If\n   * encryption key is not specified, a key will automatically be created.\n   *\n   * @default - StreamEncryption.KMS if encrypted Streams are supported in the region\n   *   or StreamEncryption.UNENCRYPTED otherwise.\n   *   StreamEncryption.KMS if an encryption key is supplied through the encryptionKey property\n   */\n  readonly encryption?: StreamEncryption;\n\n  /**\n   * External KMS key to use for stream encryption.\n   *\n   * The 'encryption' property must be set to \"Kms\".\n   *\n   * @default - Kinesis Data Streams master key ('/alias/aws/kinesis').\n   *   If encryption is set to StreamEncryption.KMS and this property is undefined, a new KMS key\n   *   will be created and associated with this stream.\n   */\n  readonly encryptionKey?: kms.IKey;\n\n  /**\n   * The capacity mode of this stream.\n   *\n   * @default StreamMode.PROVISIONED\n   */\n  readonly streamMode?: StreamMode;\n}\n\n/**\n * A Kinesis stream. Can be encrypted with a KMS key.\n *\n * @resource aws_kinesis_stream\n */\nexport class Stream extends StreamBase {\n  /**\n   * Import an existing Kinesis Stream provided an ARN\n   *\n   * @param scope The parent creating construct (usually `this`).\n   * @param id The construct's name\n   * @param streamArn Stream ARN (i.e. arn:aws:kinesis:<region>:<account-id>:stream/Foo)\n   */\n  public static fromStreamArn(\n    scope: Construct,\n    id: string,\n    streamArn: string,\n  ): IStream {\n    return Stream.fromStreamAttributes(scope, id, { streamArn });\n  }\n\n  /**\n   * Creates a Stream construct that represents an external stream.\n   *\n   * @param scope The parent creating construct (usually `this`).\n   * @param id The construct's name.\n   * @param attrs Stream import properties\n   */\n  public static fromStreamAttributes(\n    scope: Construct,\n    id: string,\n    attrs: StreamAttributes,\n  ): IStream {\n    class Import extends StreamBase {\n      public readonly streamArn = attrs.streamArn;\n      public readonly streamName = AwsStack.ofAwsConstruct(scope).splitArn(\n        attrs.streamArn,\n        ArnFormat.SLASH_RESOURCE_NAME,\n      ).resourceName!;\n      public readonly encryptionKey = attrs.encryptionKey;\n\n      protected readonly autoCreatePolicy = false;\n    }\n\n    return new Import(scope, id, {\n      environmentFromArn: attrs.streamArn,\n    });\n  }\n\n  public readonly streamArn: string;\n  public readonly streamName: string;\n  public readonly encryptionKey?: kms.IKey;\n\n  public readonly resource: kinesisStream.KinesisStream;\n\n  protected readonly autoCreatePolicy = true;\n\n  constructor(scope: Construct, id: string, props: StreamProps = {}) {\n    super(scope, id, props);\n    const name =\n      props.streamName ||\n      this.stack.uniqueResourceName(this, {\n        prefix: this.gridUUID,\n      });\n\n    let shardCount = props.shardCount;\n    const streamMode = props.streamMode;\n\n    if (streamMode === StreamMode.ON_DEMAND && shardCount !== undefined) {\n      throw new Error(\n        `streamMode must be set to ${StreamMode.PROVISIONED} (default) when specifying shardCount`,\n      );\n    }\n    if (\n      (streamMode === StreamMode.PROVISIONED || streamMode === undefined) &&\n      shardCount === undefined\n    ) {\n      shardCount = 1;\n    }\n\n    const retentionPeriodHours = props.retentionPeriod?.toHours() ?? 24;\n    if (!Token.isUnresolved(retentionPeriodHours)) {\n      if (retentionPeriodHours < 24 || retentionPeriodHours > 8760) {\n        throw new Error(\n          `retentionPeriod must be between 24 and 8760 hours. Received ${retentionPeriodHours}`,\n        );\n      }\n    }\n\n    const { streamEncryption, encryptionKey } = this.parseEncryption(props);\n    this.resource = new kinesisStream.KinesisStream(this, \"Resource\", {\n      name,\n      retentionPeriod: retentionPeriodHours,\n      shardCount,\n      ...streamEncryption,\n      ...(props.streamMode !== undefined\n        ? {\n            streamModeDetails: { streamMode: props.streamMode },\n          }\n        : undefined),\n    });\n\n    this.streamArn = this.resource.arn;\n    this.streamName = this.resource.name;\n\n    this.encryptionKey = encryptionKey;\n  }\n\n  /**\n   * Set up key properties and return the Stream encryption property from the\n   * user's configuration.\n   */\n  private parseEncryption(props: StreamProps): {\n    streamEncryption?: StreamEncryptionProperty;\n    encryptionKey?: kms.IKey;\n  } {\n    // if encryption properties are not set, default to KMS in regions where KMS is available\n    if (!props.encryption && !props.encryptionKey) {\n      const conditionName = \"AwsCdkKinesisEncryptedStreamsUnsupportedRegions\";\n      let unsupportedRegionCondition = this.stack.node.tryFindChild(\n        conditionName,\n      ) as TerraformLocal;\n\n      const unsupportedRegions = [\"cn-north-1\", \"cn-northwest-1\"];\n\n      // create a single condition for the Stack\n      if (!unsupportedRegionCondition) {\n        unsupportedRegionCondition = new TerraformLocal(\n          this.stack,\n          conditionName,\n          Fn.contains(unsupportedRegions, this.stack.region),\n        );\n      }\n\n      return {\n        streamEncryption: {\n          encryptionType: conditionalString(\n            unsupportedRegionCondition.expression,\n            \"KMS\",\n          ),\n          kmsKeyId: conditionalString(\n            unsupportedRegionCondition.expression,\n            \"alias/aws/kinesis\",\n          ),\n        },\n      };\n    }\n\n    // default based on whether encryption key is specified\n    const encryptionType =\n      props.encryption ??\n      (props.encryptionKey\n        ? StreamEncryption.KMS\n        : StreamEncryption.UNENCRYPTED);\n\n    // if encryption key is set, encryption must be set to KMS.\n    if (encryptionType !== StreamEncryption.KMS && props.encryptionKey) {\n      throw new Error(\n        `encryptionKey is specified, so 'encryption' must be set to KMS (value: ${encryptionType})`,\n      );\n    }\n\n    if (encryptionType === StreamEncryption.UNENCRYPTED) {\n      return {};\n    }\n\n    if (encryptionType === StreamEncryption.MANAGED) {\n      const encryption = {\n        encryptionType: \"KMS\",\n        kmsKeyId: \"alias/aws/kinesis\",\n      };\n      return { streamEncryption: encryption };\n    }\n\n    if (encryptionType === StreamEncryption.KMS) {\n      const encryptionKey =\n        props.encryptionKey ||\n        new kms.Key(this, \"Key\", {\n          description: `Created by ${this.node.path}`,\n        });\n\n      const streamEncryption: StreamEncryptionProperty = {\n        encryptionType: \"KMS\",\n        kmsKeyId: encryptionKey.keyArn,\n      };\n      return { encryptionKey, streamEncryption };\n    }\n\n    throw new Error(`Unexpected 'encryptionType': ${encryptionType}`);\n  }\n}\n\n/**\n * Enables or updates server-side encryption using an AWS KMS key for a specified stream.\n *\n * > 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.\n *\n * 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.\n *\n * API Limits: You can successfully apply a new AWS KMS key for server-side encryption 25 times in a rolling 24-hour period.\n *\n * 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` .\n *\n * @struct\n * @stability external\n * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-kinesis-stream-streamencryption.html\n */\nexport interface StreamEncryptionProperty {\n  /**\n   * The encryption type to use.\n   *\n   * The only valid value is `KMS` .\n   *\n   * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-kinesis-stream-streamencryption.html#cfn-kinesis-stream-streamencryption-encryptiontype\n   */\n  readonly encryptionType: string;\n\n  /**\n   * The GUID for the customer-managed AWS KMS key to use for encryption.\n   *\n   * 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` .\n   *\n   * - Key ARN example: `arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012`\n   * - Alias ARN example: `arn:aws:kms:us-east-1:123456789012:alias/MyAliasName`\n   * - Globally unique key ID example: `12345678-1234-1234-1234-123456789012`\n   * - Alias name example: `alias/MyAliasName`\n   * - Master key owned by Kinesis Data Streams: `alias/aws/kinesis`\n   *\n   * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-kinesis-stream-streamencryption.html#cfn-kinesis-stream-streamencryption-keyid\n   */\n  readonly kmsKeyId: string;\n}\n\n/**\n * What kind of server-side encryption to apply to this stream\n */\nexport enum StreamEncryption {\n  /**\n   * Records in the stream are not encrypted.\n   */\n  UNENCRYPTED = \"NONE\",\n\n  /**\n   * Server-side encryption with a KMS key managed by the user.\n   * If `encryptionKey` is specified, this key will be used, otherwise, one will be defined.\n   */\n  KMS = \"KMS\",\n\n  /**\n   * Server-side encryption with a master key managed by Amazon Kinesis\n   */\n  MANAGED = \"MANAGED\",\n}\n\n/**\n * Specifies the capacity mode to apply to this stream.\n */\nexport enum StreamMode {\n  /**\n   * Specify the provisioned capacity mode. The stream will have `shardCount` shards unless\n   * modified and will be billed according to the provisioned capacity.\n   */\n  PROVISIONED = \"PROVISIONED\",\n\n  /**\n   * Specify the on-demand capacity mode. The stream will autoscale and be billed according to the\n   * volume of data ingested and retrieved.\n   */\n  ON_DEMAND = \"ON_DEMAND\",\n}\n\n/**\n * Set string based on expression\n *\n * @param expression expression to evaluate\n * @param value value to return if expression is true, otherwise null\n */\nfunction conditionalString(expression: any, value: string): string {\n  return Token.asString(Fn.conditional(expression, Token.nullValue(), value));\n}\n"]}