terraconstructs 0.0.23 → 0.0.25

package/lib/aws/storage/table.js

@@ -0,0 +1,1054 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Table = exports.TableBase = exports.ApproximateCreationDateTimePrecision = exports.InputFormat = exports.InputCompressionType = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-dynamodb/lib/table.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const __1 = require("..");
+const dynamodb_canned_metrics_generated_1 = require("./dynamodb-canned-metrics.generated");
+const perms = require("./dynamodb-perms");
+const scalable_table_attribute_1 = require("./scalable-table-attribute");
+const shared_1 = require("./shared");
+const cloudwatch = require("../cloudwatch");
+const appscaling = require("../compute");
+const kms = require("../encryption");
+const iam = require("../iam");
+// Missing in Terraform DynamoDb Replica Configuration block
+// https://registry.terraform.io/providers/hashicorp/aws/5.88.0/docs/resources/dynamodb_table#replica
+// import { Duration } from "../../duration";
+// TODO Adopt UnscopedValidationError, ValidationError when available:
+// - https://github.com/aws/aws-cdk/pull/33382/
+// - https://github.com/aws/aws-cdk/pull/33045
+// import {
+//   UnscopedValidationError,
+//   ValidationError,
+// } from "../../core/lib/errors";
+const HASH_KEY_TYPE = "HASH";
+const RANGE_KEY_TYPE = "RANGE";
+const MAX_LOCAL_SECONDARY_INDEX_COUNT = 5;
+/**
+ * Type of compression to use for imported data.
+ */
+var InputCompressionType;
+(function (InputCompressionType) {
+    /**
+     * GZIP compression.
+     */
+    InputCompressionType["GZIP"] = "GZIP";
+    /**
+     * ZSTD compression.
+     */
+    InputCompressionType["ZSTD"] = "ZSTD";
+    /**
+     * No compression.
+     */
+    InputCompressionType["NONE"] = "NONE";
+})(InputCompressionType || (exports.InputCompressionType = InputCompressionType = {}));
+/**
+ * The format of the source data.
+ */
+class InputFormat {
+    /**
+     * DynamoDB JSON format.
+     */
+    static dynamoDBJson() {
+        return new (class extends InputFormat {
+            _render() {
+                return {
+                    inputFormat: "DYNAMODB_JSON",
+                };
+            }
+        })();
+    }
+    /**
+     * Amazon Ion format.
+     */
+    static ion() {
+        return new (class extends InputFormat {
+            _render() {
+                return {
+                    inputFormat: "ION",
+                };
+            }
+        })();
+    }
+    /**
+     * CSV format.
+     */
+    static csv(options) {
+        if (options?.delimiter &&
+            (!this.validCsvDelimiters.includes(options.delimiter) ||
+                options.delimiter.length !== 1)) {
+            // throw new UnscopedValidationError(
+            throw new Error([
+                "Delimiter must be a single character and one of the following:",
+                `${this.readableValidCsvDelimiters.join(", ")},`,
+                `got '${options.delimiter}'`,
+            ].join(" "));
+        }
+        return new (class extends InputFormat {
+            _render() {
+                return {
+                    inputFormat: "CSV",
+                    inputFormatOptions: options
+                        ? {
+                            csv: {
+                                delimiter: options?.delimiter,
+                                headerList: options?.headerList,
+                            },
+                        }
+                        : undefined,
+                };
+            }
+        })();
+    }
+}
+exports.InputFormat = InputFormat;
+_a = JSII_RTTI_SYMBOL_1;
+InputFormat[_a] = { fqn: "terraconstructs.aws.storage.InputFormat", version: "0.0.25" };
+InputFormat.validCsvDelimiters = [",", "\t", ":", ";", "|", " "];
+InputFormat.readableValidCsvDelimiters = [
+    "comma (,)",
+    "tab (\\t)",
+    "colon (:)",
+    "semicolon (;)",
+    "pipe (|)",
+    "space ( )",
+];
+/**
+ * The precision associated with the DynamoDB write timestamps that will be replicated to Kinesis.
+ * The default setting for record timestamp precision is microseconds. You can change this setting at any time.
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-dynamodb-table-kinesisstreamspecification.html#aws-properties-dynamodb-table-kinesisstreamspecification-properties
+ */
+var ApproximateCreationDateTimePrecision;
+(function (ApproximateCreationDateTimePrecision) {
+    /**
+     * Millisecond precision
+     */
+    ApproximateCreationDateTimePrecision["MILLISECOND"] = "MILLISECOND";
+    /**
+     * Microsecond precision
+     */
+    ApproximateCreationDateTimePrecision["MICROSECOND"] = "MICROSECOND";
+})(ApproximateCreationDateTimePrecision || (exports.ApproximateCreationDateTimePrecision = ApproximateCreationDateTimePrecision = {}));
+class TableBase extends __1.AwsConstructBase {
+    constructor() {
+        super(...arguments);
+        this.regionalArns = new Array();
+    }
+    get outputs() {
+        return {
+            tableArn: this.tableArn,
+            tableName: this.tableName,
+            tableStreamArn: this.tableStreamArn,
+        };
+    }
+    grant(grantee, ...actions) {
+        const resources = [
+            this.tableArn,
+            cdktf_1.Lazy.stringValue({
+                produce: () => (this.hasIndex ? `${this.tableArn}/index/*` : undefined),
+            }),
+            ...this.regionalArns,
+            ...this.regionalArns.map((arn) => cdktf_1.Lazy.stringValue({
+                produce: () => (this.hasIndex ? `${arn}/index/*` : undefined),
+            })),
+        ];
+        return iam.Grant.addToPrincipalOrResource({
+            grantee,
+            actions,
+            resourceArns: resources.filter((r) => r !== undefined),
+            resource: this, // Grant will take the principal from the grantee
+        });
+    }
+    grantStream(grantee, ...actions) {
+        if (!this.tableStreamArn) {
+            // throw new ValidationError(
+            throw new Error(`DynamoDB Streams must be enabled on the table ${this.node.path}`);
+        }
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions,
+            resourceArns: [this.tableStreamArn],
+            scope: this,
+        });
+    }
+    grantReadData(grantee) {
+        const tableActions = perms.READ_DATA_ACTIONS_TABLE_SAFE.concat(perms.DESCRIBE_TABLE);
+        // If streams are available, also grant stream-specific actions
+        if (this.tableStreamArn) {
+            return this.combinedGrant(grantee, {
+                keyActions: perms.KEY_READ_ACTIONS,
+                tableActions,
+                streamActions: perms.READ_DATA_ACTIONS_STREAM_ONLY,
+            });
+        }
+        return this.combinedGrant(grantee, {
+            keyActions: perms.KEY_READ_ACTIONS,
+            tableActions,
+        });
+    }
+    grantTableListStreams(grantee) {
+        if (!this.tableStreamArn) {
+            // throw new ValidationError(
+            throw new Error(`DynamoDB Streams must be enabled on the table ${this.node.path}`);
+        }
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions: ["dynamodb:ListStreams"],
+            resourceArns: ["*"],
+        });
+    }
+    grantStreamRead(grantee) {
+        this.grantTableListStreams(grantee);
+        return this.combinedGrant(grantee, {
+            keyActions: perms.KEY_READ_ACTIONS,
+            streamActions: perms.READ_STREAM_DATA_ACTIONS,
+        });
+    }
+    grantWriteData(grantee) {
+        const tableActions = perms.WRITE_DATA_ACTIONS.concat(perms.DESCRIBE_TABLE);
+        const keyActions = perms.KEY_READ_ACTIONS.concat(perms.KEY_WRITE_ACTIONS);
+        return this.combinedGrant(grantee, { keyActions, tableActions });
+    }
+    grantReadWriteData(grantee) {
+        const tableActions = perms.READ_DATA_ACTIONS.concat(perms.WRITE_DATA_ACTIONS).concat(perms.DESCRIBE_TABLE);
+        const keyActions = perms.KEY_READ_ACTIONS.concat(perms.KEY_WRITE_ACTIONS);
+        return this.combinedGrant(grantee, { keyActions, tableActions });
+    }
+    grantFullAccess(grantee) {
+        const keyActions = perms.KEY_READ_ACTIONS.concat(perms.KEY_WRITE_ACTIONS);
+        return this.combinedGrant(grantee, {
+            keyActions,
+            tableActions: ["dynamodb:*"],
+        });
+    }
+    addToResourcePolicy(statement) {
+        if (!this.resourcePolicy) {
+            // ensure a policy exists and is associated with the table
+            this.resourcePolicy = new iam.PolicyDocument(this, "Policy", {
+                statement: [],
+            });
+            new provider_aws_1.dynamodbResourcePolicy.DynamodbResourcePolicy(this, "PolicyAttachment", {
+                policy: this.resourcePolicy.json,
+                resourceArn: this.tableArn,
+            });
+        }
+        this.resourcePolicy.addStatements(statement);
+        return {
+            statementAdded: true,
+            policyDependable: this,
+        };
+    }
+    metric(metricName, props) {
+        return new cloudwatch.Metric({
+            namespace: "AWS/DynamoDB",
+            metricName,
+            dimensionsMap: {
+                TableName: this.tableName,
+            },
+            ...props,
+        }).attachTo(this);
+    }
+    metricConsumedReadCapacityUnits(props) {
+        return this.cannedMetric(dynamodb_canned_metrics_generated_1.DynamoDBMetrics.consumedReadCapacityUnitsSum, props);
+    }
+    metricConsumedWriteCapacityUnits(props) {
+        return this.cannedMetric(dynamodb_canned_metrics_generated_1.DynamoDBMetrics.consumedWriteCapacityUnitsSum, props);
+    }
+    /** @deprecated use `metricSystemErrorsForOperations`. */
+    metricSystemErrors(props) {
+        if (!props?.dimensionsMap?.Operation) {
+            // 'Operation' must be passed because its an operational metric.
+            // throw new ValidationError(
+            throw new Error("'Operation' dimension must be passed for the 'SystemErrors' metric.");
+        }
+        const dimensionsMap = {
+            TableName: this.tableName,
+            ...props?.dimensionsMap,
+        };
+        return this.metric("SystemErrors", {
+            statistic: "sum",
+            ...props,
+            dimensionsMap,
+        });
+    }
+    metricUserErrors(props) {
+        if (props?.dimensionsMap) {
+            // throw new ValidationError(
+            throw new Error("'dimensionsMap' is not supported for the 'UserErrors' metric");
+        }
+        return this.metric("UserErrors", {
+            statistic: "sum",
+            ...props,
+            dimensionsMap: {},
+        });
+    }
+    metricConditionalCheckFailedRequests(props) {
+        return this.metric("ConditionalCheckFailedRequests", {
+            statistic: "sum",
+            ...props,
+        });
+    }
+    /** @deprecated Do not use this function. It returns an invalid metric. Use `metricThrottledRequestsForOperation` instead. */
+    metricThrottledRequests(props) {
+        return this.metric("ThrottledRequests", { statistic: "sum", ...props });
+    }
+    metricSuccessfulRequestLatency(props) {
+        if (!props?.dimensionsMap?.Operation) {
+            // throw new ValidationError(
+            throw new Error("'Operation' dimension must be passed for the 'SuccessfulRequestLatency' metric.");
+        }
+        const dimensionsMap = {
+            TableName: this.tableName,
+            Operation: props.dimensionsMap.Operation,
+        };
+        return new cloudwatch.Metric({
+            ...dynamodb_canned_metrics_generated_1.DynamoDBMetrics.successfulRequestLatencyAverage(dimensionsMap),
+            ...props,
+            dimensionsMap,
+        }).attachTo(this);
+    }
+    metricThrottledRequestsForOperation(operation, props) {
+        return new cloudwatch.Metric({
+            ...dynamodb_canned_metrics_generated_1.DynamoDBMetrics.throttledRequestsSum({
+                Operation: operation,
+                TableName: this.tableName,
+            }),
+            ...props,
+        }).attachTo(this);
+    }
+    metricThrottledRequestsForOperations(props) {
+        return this.sumMetricsForOperations("ThrottledRequests", "Sum of throttled requests across all operations", props);
+    }
+    metricSystemErrorsForOperations(props) {
+        return this.sumMetricsForOperations("SystemErrors", "Sum of errors across all operations", props);
+    }
+    sumMetricsForOperations(metricName, expressionLabel, props) {
+        if (props?.dimensionsMap?.Operation) {
+            // throw new ValidationError(
+            throw new Error("The Operation dimension is not supported. Use the 'operations' property.");
+        }
+        const operations = props?.operations ?? Object.values(shared_1.Operation);
+        const values = this.createMetricsForOperations(metricName, operations, {
+            statistic: "sum",
+            ...props,
+        });
+        return new cloudwatch.MathExpression({
+            expression: `${Object.keys(values).join(" + ")}`,
+            usingMetrics: { ...values },
+            color: props?.color,
+            label: expressionLabel,
+            period: props?.period,
+        });
+    }
+    createMetricsForOperations(metricName, operations, props, metricNameMapper) {
+        const metrics = {};
+        const mapper = metricNameMapper ?? ((op) => op.toLowerCase());
+        if (props?.dimensionsMap?.Operation) {
+            // throw new ValidationError(
+            throw new Error("Invalid properties. Operation dimension is not supported when calculating operational metrics");
+        }
+        for (const operation of operations) {
+            const metric = this.metric(metricName, {
+                ...props,
+                dimensionsMap: {
+                    TableName: this.tableName,
+                    Operation: operation,
+                    ...props?.dimensionsMap,
+                },
+            });
+            const operationMetricName = mapper(operation);
+            const firstChar = operationMetricName.charAt(0);
+            if (firstChar === firstChar.toUpperCase()) {
+                // https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/using-metric-math.html#metric-math-syntax
+                // throw new ValidationError(
+                throw new Error(`Mapper generated an illegal operation metric name: ${operationMetricName}. Must start with a lowercase letter`);
+            }
+            metrics[operationMetricName] = metric;
+        }
+        return metrics;
+    }
+    combinedGrant(grantee, opts) {
+        if (this.encryptionKey && opts.keyActions) {
+            this.encryptionKey.grant(grantee, ...opts.keyActions);
+        }
+        if (opts.tableActions) {
+            const resources = [
+                this.tableArn,
+                cdktf_1.Lazy.stringValue({
+                    produce: () => this.hasIndex ? `${this.tableArn}/index/*` : undefined,
+                }),
+                ...this.regionalArns,
+                ...this.regionalArns.map((arn) => cdktf_1.Lazy.stringValue({
+                    produce: () => (this.hasIndex ? `${arn}/index/*` : undefined),
+                })),
+            ];
+            const ret = iam.Grant.addToPrincipalOrResource({
+                grantee,
+                actions: opts.tableActions,
+                resourceArns: resources.filter((r) => r !== undefined),
+                resource: this,
+            });
+            return ret;
+        }
+        if (opts.streamActions) {
+            if (!this.tableStreamArn) {
+                // throw new ValidationError(
+                throw new Error(`DynamoDB Streams must be enabled on the table ${this.node.path}`);
+            }
+            const ret = iam.Grant.addToPrincipalOrResource({
+                grantee,
+                actions: opts.streamActions,
+                resourceArns: [this.tableStreamArn],
+                resource: this,
+            });
+            return ret;
+        }
+        // throw new ValidationError(
+        throw new Error(`Unexpected grant combination, actions must be provided for table or stream.`);
+    }
+    cannedMetric(fn, props) {
+        return new cloudwatch.Metric({
+            ...fn({ TableName: this.tableName }),
+            ...props,
+        }).attachTo(this);
+    }
+}
+exports.TableBase = TableBase;
+_b = JSII_RTTI_SYMBOL_1;
+TableBase[_b] = { fqn: "terraconstructs.aws.storage.TableBase", version: "0.0.25" };
+/**
+ * Provides a DynamoDB table.
+ */
+class Table extends TableBase {
+    /**
+     * Permits an IAM Principal to list all DynamoDB Streams.
+     * @deprecated Use `#grantTableListStreams` for more granular permission
+     * @param grantee The principal (no-op if undefined)
+     */
+    static grantListStreams(grantee) {
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions: ["dynamodb:ListStreams"],
+            resourceArns: ["*"],
+        });
+    }
+    /**
+     * Creates a Table construct that represents an external table via table name.
+     *
+     * @param scope The parent creating construct (usually `this`).
+     * @param id The construct's name.
+     * @param tableName The table's name.
+     */
+    static fromTableName(scope, id, tableName) {
+        return Table.fromTableAttributes(scope, id, { tableName });
+    }
+    /**
+     * Creates a Table construct that represents an external table via table arn.
+     *
+     * @param scope The parent creating construct (usually `this`).
+     * @param id The construct's name.
+     * @param tableArn The table's ARN.
+     */
+    static fromTableArn(scope, id, tableArn) {
+        return Table.fromTableAttributes(scope, id, { tableArn });
+    }
+    /**
+     * Creates a Table construct that represents an external table.
+     *
+     * @param scope The parent creating construct (usually `this`).
+     * @param id The construct's name.
+     * @param attrs A `TableAttributes` object.
+     */
+    static fromTableAttributes(scope, id, attrs) {
+        class Import extends TableBase {
+            constructor(props, _tableArn, tableName, tableStreamArn) {
+                super(scope, id, props);
+                this.hasIndex = (attrs.grantIndexPermissions ?? false) ||
+                    (attrs.globalIndexes ?? []).length > 0 ||
+                    (attrs.localIndexes ?? []).length > 0;
+                this.tableArn = _tableArn;
+                this.tableName = tableName;
+                this.tableStreamArn = tableStreamArn;
+                this.encryptionKey = attrs.encryptionKey;
+            }
+        }
+        let name;
+        let arn;
+        const stack = __1.AwsStack.ofAwsConstruct(scope);
+        if (!attrs.tableName) {
+            if (!attrs.tableArn) {
+                // throw new ValidationError(
+                throw new Error("One of tableName or tableArn is required!");
+            }
+            arn = attrs.tableArn;
+            const maybeTableName = stack.splitArn(attrs.tableArn, __1.ArnFormat.SLASH_RESOURCE_NAME).resourceName;
+            if (!maybeTableName) {
+                // throw new ValidationError(
+                throw new Error("ARN for DynamoDB table must be in the form: arn:<partition>:dynamodb:<region>:<account>:table/<table-name>");
+            }
+            name = maybeTableName;
+        }
+        else {
+            if (attrs.tableArn) {
+                // throw new ValidationError(
+                throw new Error("Only one of tableArn or tableName can be provided");
+            }
+            name = attrs.tableName;
+            arn = stack.formatArn({
+                service: "dynamodb",
+                resource: "table",
+                resourceName: attrs.tableName,
+            });
+        }
+        return new Import({ environmentFromArn: arn }, arn, name, attrs.tableStreamArn);
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.attributeDefinitionsInternal = new Array();
+        this.globalSecondaryIndexesInternal = new Array();
+        this.localSecondaryIndexesInternal = new Array();
+        this.secondaryIndexSchemas = new Map();
+        this.nonKeyAttributes = new Set();
+        this.tableScaling = {};
+        this.indexScaling = new Map();
+        const physicalTableName = props.tableName ?? this.stack.uniqueResourceName(this);
+        const { sseSpecification, encryptionKey } = this.parseEncryption(props);
+        this.encryptionKey = encryptionKey;
+        const pointInTimeRecovery = this.renderPointInTimeRecovery(props);
+        // error if both replicationRegions and replicaSpecification are specified
+        if (props.replicationRegions && props.replicaSpecification) {
+            // throw new ValidationError(
+            throw new Error("You cannot specify both `replicationRegions` and `replicaSpecification`");
+        }
+        let streamSpecification;
+        if ((props.replicationRegions && props.replicationRegions.length > 0) ||
+            (props.replicaSpecification && props.replicaSpecification.length > 0)) {
+            if (props.stream && props.stream !== shared_1.StreamViewType.NEW_AND_OLD_IMAGES) {
+                // throw new ValidationError(
+                throw new Error("`stream` must be set to `NEW_AND_OLD_IMAGES` when specifying `replicationRegions`");
+            }
+            this.billingMode = props.billingMode ?? shared_1.BillingMode.PAY_PER_REQUEST;
+            streamSpecification = {
+                streamEnabled: true,
+                streamViewType: shared_1.StreamViewType.NEW_AND_OLD_IMAGES,
+            };
+        }
+        else {
+            this.billingMode = props.billingMode ?? shared_1.BillingMode.PROVISIONED;
+            if (props.stream) {
+                streamSpecification = {
+                    streamEnabled: true,
+                    streamViewType: props.stream,
+                };
+            }
+        }
+        this.validateProvisioning(props);
+        this.addKey(props.partitionKey, HASH_KEY_TYPE);
+        this.tablePartitionKey = props.partitionKey;
+        if (props.sortKey) {
+            this.addKey(props.sortKey, RANGE_KEY_TYPE);
+            this.tableSortKey = props.sortKey;
+        }
+        this._replicas = this.renderReplicas(props.replicationRegions, props.replicaSpecification);
+        if (this._replicas && this._replicas.length > 0) {
+            this._replicas.forEach((r) => 
+            // Save regional arns for grantXxx() methods
+            this.regionalArns.push(this.stack.formatArn({
+                region: r.regionName,
+                service: "dynamodb",
+                resource: "table",
+                resourceName: physicalTableName,
+            })));
+        }
+        this._resource = new provider_aws_1.dynamodbTable.DynamodbTable(this, "Resource", {
+            name: physicalTableName,
+            hashKey: this.tablePartitionKey.name,
+            rangeKey: this.tableSortKey?.name,
+            attribute: this.attributeDefinitionsInternal,
+            globalSecondaryIndex: cdktf_1.Lazy.anyValue({
+                produce: () => this.globalSecondaryIndexesInternal.map(provider_aws_1.dynamodbTable.dynamodbTableGlobalSecondaryIndexToTerraform),
+            }, { omitEmptyArray: true }),
+            localSecondaryIndex: cdktf_1.Lazy.anyValue({
+                produce: () => this.localSecondaryIndexesInternal.map(provider_aws_1.dynamodbTable.dynamodbTableLocalSecondaryIndexToTerraform),
+            }, { omitEmptyArray: true }),
+            pointInTimeRecovery,
+            billingMode: this.billingMode,
+            readCapacity: this.billingMode === shared_1.BillingMode.PROVISIONED
+                ? (props.readCapacity ?? 5)
+                : undefined,
+            writeCapacity: this.billingMode === shared_1.BillingMode.PROVISIONED
+                ? (props.writeCapacity ?? 5)
+                : undefined,
+            onDemandThroughput: this.billingMode === shared_1.BillingMode.PAY_PER_REQUEST &&
+                (props.maxReadRequestUnits || props.maxWriteRequestUnits)
+                ? {
+                    maxReadRequestUnits: props.maxReadRequestUnits,
+                    maxWriteRequestUnits: props.maxWriteRequestUnits,
+                }
+                : undefined,
+            serverSideEncryption: sseSpecification,
+            streamEnabled: streamSpecification?.streamEnabled,
+            streamViewType: streamSpecification?.streamViewType,
+            tableClass: props.tableClass,
+            ttl: props.timeToLiveAttribute
+                ? { attributeName: props.timeToLiveAttribute, enabled: true }
+                : undefined,
+            deletionProtectionEnabled: props.deletionProtection,
+            importTable: this.renderImportSourceSpecification(props.importSource),
+            replica: this._replicas,
+            // resourcePolicy: props.resourcePolicy ? { policyDocument: this.stack.toJsonString(props.resourcePolicy.toJSON()) } : undefined, // Not in TF resource
+            // TODO: https://github.com/hashicorp/terraform-provider-aws/issues/43142
+            // warmThroughput: props.warmThroughput ?? undefined, // Not in TF resource
+        });
+        this.tableArn = this._resource.arn;
+        this.tableName = this._resource.name;
+        this.tableStreamArn = streamSpecification?.streamEnabled
+            ? this._resource.streamArn
+            : undefined;
+        this.resourcePolicy = props.resourcePolicy;
+        if (this.resourcePolicy) {
+            new provider_aws_1.dynamodbResourcePolicy.DynamodbResourcePolicy(this, "ResourcePolicy", {
+                policy: this.resourcePolicy.json,
+                resourceArn: this.tableArn,
+            });
+        }
+        if (props.kinesisStream) {
+            new provider_aws_1.dynamodbKinesisStreamingDestination.DynamodbKinesisStreamingDestination(this, "KinesisStreamingDestination", {
+                tableName: this.tableName,
+                streamArn: props.kinesisStream.streamArn,
+                ...(props.kinesisPrecisionTimestamp && {
+                    approximateCreationDateTimePrecision: props.kinesisPrecisionTimestamp,
+                }),
+            });
+        }
+        if (props.contributorInsightsEnabled) {
+            // TODO: Generate conntributor insights per Global Secondary Index
+            // this.globalSecondaryIndexesInternal
+            new provider_aws_1.dynamodbContributorInsights.DynamodbContributorInsights(this, "ContributorInsights", {
+                tableName: this.tableName,
+                // TODO: use for each on gli iterator
+                // indexName: iterator.value,
+            });
+        }
+        // Commenting out scalingRole initialization - let Terraform auto-create service-linked role
+        // this.scalingRole = this.makeScalingRole();
+        this.node.addValidation({ validate: () => this.validateTable() });
+    }
+    addGlobalSecondaryIndex(props) {
+        this.validateProvisioningGSI(props);
+        this.validateIndexName(props.indexName);
+        const gsiProjection = this.buildIndexProjection(props);
+        this.registerAttribute(props.partitionKey);
+        if (props.sortKey) {
+            this.registerAttribute(props.sortKey);
+        }
+        this.globalSecondaryIndexesInternal.push({
+            name: props.indexName,
+            hashKey: props.partitionKey.name,
+            rangeKey: props.sortKey?.name,
+            projectionType: gsiProjection.projectionType,
+            nonKeyAttributes: gsiProjection.nonKeyAttributes,
+            readCapacity: this.billingMode === shared_1.BillingMode.PROVISIONED
+                ? (props.readCapacity ?? 5)
+                : undefined,
+            writeCapacity: this.billingMode === shared_1.BillingMode.PROVISIONED
+                ? (props.writeCapacity ?? 5)
+                : undefined,
+            onDemandThroughput: this.billingMode === shared_1.BillingMode.PAY_PER_REQUEST &&
+                (props.maxReadRequestUnits || props.maxWriteRequestUnits)
+                ? {
+                    maxReadRequestUnits: props.maxReadRequestUnits,
+                    maxWriteRequestUnits: props.maxWriteRequestUnits,
+                }
+                : undefined,
+            // contributorInsightsEnabled: props.contributorInsightsEnabled, // Not in TF GSI block
+            // warmThroughput: props.warmThroughput, // Not in TF GSI block
+        });
+        this.secondaryIndexSchemas.set(props.indexName, {
+            partitionKey: props.partitionKey,
+            sortKey: props.sortKey,
+        });
+        this.indexScaling.set(props.indexName, {});
+    }
+    addLocalSecondaryIndex(props) {
+        if (this.localSecondaryIndexesInternal.length >=
+            MAX_LOCAL_SECONDARY_INDEX_COUNT) {
+            throw new RangeError(`A maximum number of local secondary index per table is ${MAX_LOCAL_SECONDARY_INDEX_COUNT}`);
+        }
+        this.validateIndexName(props.indexName);
+        if (!this.tablePartitionKey) {
+            // throw new ValidationError(
+            throw new Error("Table partition key must be defined before adding local secondary index");
+        }
+        this.registerAttribute(this.tablePartitionKey);
+        this.registerAttribute(props.sortKey);
+        const lsiProjection = this.buildIndexProjection(props);
+        this.localSecondaryIndexesInternal.push({
+            name: props.indexName,
+            rangeKey: props.sortKey.name,
+            projectionType: lsiProjection.projectionType,
+            nonKeyAttributes: lsiProjection.nonKeyAttributes,
+        });
+        this.secondaryIndexSchemas.set(props.indexName, {
+            partitionKey: this.tablePartitionKey,
+            sortKey: props.sortKey,
+        });
+    }
+    autoScaleReadCapacity(props) {
+        if (this.tableScaling.scalableReadAttribute) {
+            // throw new ValidationError(
+            throw new Error("Read AutoScaling already enabled for this table");
+        }
+        if (this.billingMode === shared_1.BillingMode.PAY_PER_REQUEST) {
+            // throw new ValidationError(
+            throw new Error("AutoScaling is not available for tables with PAY_PER_REQUEST billing mode");
+        }
+        return (this.tableScaling.scalableReadAttribute =
+            new scalable_table_attribute_1.ScalableTableAttribute(this, "ReadScaling", {
+                serviceNamespace: appscaling.ServiceNamespace.DYNAMODB,
+                resourceId: `table/${this.tableName}`,
+                dimension: "dynamodb:table:ReadCapacityUnits",
+                // role: this.scalingRole, // Commenting out - let Terraform use service-linked role
+                ...props,
+            }));
+    }
+    autoScaleWriteCapacity(props) {
+        if (this.tableScaling.scalableWriteAttribute) {
+            // throw new ValidationError(
+            throw new Error("Write AutoScaling already enabled for this table");
+        }
+        if (this.billingMode === shared_1.BillingMode.PAY_PER_REQUEST) {
+            // throw new ValidationError(
+            throw new Error("AutoScaling is not available for tables with PAY_PER_REQUEST billing mode");
+        }
+        this.tableScaling.scalableWriteAttribute = new scalable_table_attribute_1.ScalableTableAttribute(this, "WriteScaling", {
+            serviceNamespace: appscaling.ServiceNamespace.DYNAMODB,
+            resourceId: `table/${this.tableName}`,
+            dimension: "dynamodb:table:WriteCapacityUnits",
+            // role: this.scalingRole, // Commenting out - let Terraform use service-linked role
+            ...props,
+        });
+        // If there are replicas, they depend on the write scaling policy of the main table.
+        // This is not explicitly modeled in TF but was handled by CustomResource dependencies in CDK.
+        // For TF, this dependency is implicit if the provider handles it, or might need explicit dependsOn if issues arise.
+        return this.tableScaling.scalableWriteAttribute;
+    }
+    autoScaleGlobalSecondaryIndexReadCapacity(indexName, props) {
+        if (this.billingMode === shared_1.BillingMode.PAY_PER_REQUEST) {
+            // throw new ValidationError(
+            throw new Error("AutoScaling is not available for tables with PAY_PER_REQUEST billing mode");
+        }
+        const attributePair = this.indexScaling.get(indexName);
+        if (!attributePair) {
+            // throw new ValidationError(
+            throw new Error(`No global secondary index with name ${indexName}`);
+        }
+        if (attributePair.scalableReadAttribute) {
+            // throw new ValidationError(
+            throw new Error("Read AutoScaling already enabled for this index");
+        }
+        return (attributePair.scalableReadAttribute = new scalable_table_attribute_1.ScalableTableAttribute(this, `${indexName}ReadScaling`, {
+            serviceNamespace: appscaling.ServiceNamespace.DYNAMODB,
+            resourceId: `table/${this.tableName}/index/${indexName}`,
+            dimension: "dynamodb:index:ReadCapacityUnits",
+            // role: this.scalingRole, // Commenting out - let Terraform use service-linked role
+            ...props,
+        }));
+    }
+    autoScaleGlobalSecondaryIndexWriteCapacity(indexName, props) {
+        if (this.billingMode === shared_1.BillingMode.PAY_PER_REQUEST) {
+            // throw new ValidationError(
+            throw new Error("AutoScaling is not available for tables with PAY_PER_REQUEST billing mode");
+        }
+        const attributePair = this.indexScaling.get(indexName);
+        if (!attributePair) {
+            // throw new ValidationError(
+            throw new Error(`No global secondary index with name ${indexName}`);
+        }
+        if (attributePair.scalableWriteAttribute) {
+            // throw new ValidationError(
+            throw new Error("Write AutoScaling already enabled for this index");
+        }
+        return (attributePair.scalableWriteAttribute = new scalable_table_attribute_1.ScalableTableAttribute(this, `${indexName}WriteScaling`, {
+            serviceNamespace: appscaling.ServiceNamespace.DYNAMODB,
+            resourceId: `table/${this.tableName}/index/${indexName}`,
+            dimension: "dynamodb:index:WriteCapacityUnits",
+            // role: this.scalingRole, // Commenting out - let Terraform use service-linked role
+            ...props,
+        }));
+    }
+    schema(indexName) {
+        if (!indexName) {
+            return {
+                partitionKey: this.tablePartitionKey,
+                sortKey: this.tableSortKey,
+            };
+        }
+        const schema = this.secondaryIndexSchemas.get(indexName);
+        if (!schema) {
+            // throw new ValidationError(
+            throw new Error(`Cannot find schema for index: ${indexName}. Use 'addGlobalSecondaryIndex' or 'addLocalSecondaryIndex' to add index`);
+        }
+        return schema;
+    }
+    validateTable() {
+        const errors = new Array();
+        if (!this.tablePartitionKey) {
+            errors.push("A partition key must be specified");
+        }
+        if (this.localSecondaryIndexesInternal.length > 0 && !this.tableSortKey) {
+            errors.push("A sort key of the table must be specified to add local secondary indexes");
+        }
+        if (this._replicas &&
+            this._replicas.length > 0 &&
+            this.billingMode === shared_1.BillingMode.PROVISIONED) {
+            const writeAutoScaleAttribute = this.tableScaling.scalableWriteAttribute;
+            if (!writeAutoScaleAttribute) {
+                errors.push("A global Table that uses PROVISIONED as the billing mode needs auto-scaled write capacity. " +
+                    "Use the autoScaleWriteCapacity() method to enable it.");
+            }
+            else if (!writeAutoScaleAttribute._scalingPolicyCreated) {
+                errors.push("A global Table that uses PROVISIONED as the billing mode needs auto-scaled write capacity with a policy. " +
+                    "Call one of the scaleOn*() methods of the object returned from autoScaleWriteCapacity()");
+            }
+        }
+        return errors;
+    }
+    validateProvisioning(props) {
+        if (this.billingMode === shared_1.BillingMode.PAY_PER_REQUEST) {
+            if (props.readCapacity !== undefined ||
+                props.writeCapacity !== undefined) {
+                // throw new ValidationError(
+                throw new Error("You cannot provision read and write capacity for a table with PAY_PER_REQUEST billing mode");
+            }
+        }
+    }
+    validateProvisioningGSI(props) {
+        if (this.billingMode === shared_1.BillingMode.PAY_PER_REQUEST) {
+            if (props.readCapacity !== undefined ||
+                props.writeCapacity !== undefined) {
+                // throw new ValidationError(
+                throw new Error("You cannot provision read and write capacity for a GSI with PAY_PER_REQUEST billing mode on the table");
+            }
+        }
+    }
+    validateIndexName(indexName) {
+        if (this.secondaryIndexSchemas.has(indexName)) {
+            // throw new ValidationError(
+            throw new Error(`A duplicate index name, ${indexName}, is not allowed`);
+        }
+    }
+    validateNonKeyAttributes(nonKeyAttributes) {
+        if (this.nonKeyAttributes.size + nonKeyAttributes.length > 100) {
+            throw new RangeError("A maximum number of nonKeyAttributes across all of secondary indexes is 100");
+        }
+        nonKeyAttributes.forEach((att) => this.nonKeyAttributes.add(att));
+    }
+    renderPointInTimeRecovery(props) {
+        if (props.pointInTimeRecoverySpecification !== undefined &&
+            props.pointInTimeRecovery !== undefined) {
+            // throw new ValidationError(
+            throw new Error("`pointInTimeRecoverySpecification` and `pointInTimeRecovery` are set. Use `pointInTimeRecoverySpecification` only.");
+        }
+        const spec = props.pointInTimeRecoverySpecification;
+        if (spec?.recoveryPeriodInDays) {
+            // TODO: Upgrade provider to 5.98.0 to support recoveryPeriodInDays
+            cdktf_1.Annotations.of(this).addWarning("Warning: recoveryPeriodInDays is not supported until provider aws is upgraded to 5.98.0 and will be ignored.");
+        }
+        const enabled = spec?.pointInTimeRecoveryEnabled ?? props.pointInTimeRecovery;
+        if (enabled === undefined)
+            return undefined;
+        return { enabled };
+    }
+    buildIndexProjection(props) {
+        if (props.projectionType === shared_1.ProjectionType.INCLUDE &&
+            !props.nonKeyAttributes) {
+            // throw new ValidationError(
+            throw new Error(`Non-key attributes should be specified when using ${shared_1.ProjectionType.INCLUDE} projection type`);
+        }
+        if (props.projectionType !== shared_1.ProjectionType.INCLUDE &&
+            props.nonKeyAttributes) {
+            // throw new ValidationError(
+            throw new Error(`Non-key attributes should not be specified when not using ${shared_1.ProjectionType.INCLUDE} projection type`);
+        }
+        if (props.nonKeyAttributes) {
+            this.validateNonKeyAttributes(props.nonKeyAttributes);
+        }
+        return {
+            projectionType: props.projectionType ?? shared_1.ProjectionType.ALL,
+            nonKeyAttributes: props.nonKeyAttributes,
+        };
+    }
+    // TODO: keyType is unused
+    addKey(attribute, _keyType) {
+        const existingAttr = this.attributeDefinitionsInternal.find((def) => def.name === attribute.name);
+        if (existingAttr && existingAttr.type !== attribute.type) {
+            // throw new ValidationError(
+            throw new Error(`Unable to specify ${attribute.name} as ${attribute.type} because it was already defined as ${existingAttr.type}`);
+        }
+        if (!existingAttr) {
+            this.attributeDefinitionsInternal.push({
+                name: attribute.name,
+                type: attribute.type,
+            });
+        }
+        // For the main table, hashKey and rangeKey are set directly on the resource.
+        // For GSIs/LSIs, they are part of their respective blocks.
+    }
+    registerAttribute(attribute) {
+        const existingDef = this.attributeDefinitionsInternal.find((def) => def.name === attribute.name);
+        if (existingDef && existingDef.type !== attribute.type) {
+            // throw new ValidationError(
+            throw new Error(`Unable to specify ${attribute.name} as ${attribute.type} because it was already defined as ${existingDef.type}`);
+        }
+        if (!existingDef) {
+            this.attributeDefinitionsInternal.push({
+                name: attribute.name,
+                type: attribute.type,
+            });
+        }
+    }
+    // Commenting out makeScalingRole method - Terraform handles service-linked roles automatically
+    // Unlike AWS CDK CloudFormation implementation, Terraform AWS provider creates appropriate
+    // service-linked roles when roleArn is omitted from aws_appautoscaling_target resource
+    // private makeScalingRole(): iam.IRole {
+    //   // Use a Service Linked Role.
+    //   // https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html
+    //   return iam.Role.fromRoleArn(
+    //     this,
+    //     "ScalingRole",
+    //     this.stack.formatArn({
+    //       service: "iam",
+    //       region: "", // SLRs are global
+    //       resource:
+    //         "role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com",
+    //       resourceName: "AWSServiceRoleForApplicationAutoScaling_DynamoDBTable",
+    //       // TODO: Is this needed?
+    //       // arnFormat: ArnFormat.SLASH_RESOURCE_SLASH_RESOURCE_NAME, // Special format for SLRs
+    //     }),
+    //   );
+    // }
+    /**
+     * Creates replica tables
+     *
+     * @param regions regions where to create tables
+     */
+    renderReplicas(regions, replicaSpecification) {
+        if (replicaSpecification && replicaSpecification.length > 0) {
+            if (!cdktf_1.Token.isUnresolved(this.stack.region) &&
+                replicaSpecification.some((replica) => replica.regionName === this.stack.region)) {
+                // throw new ValidationError(
+                throw new Error("`replicaSpecification` cannot include the region where this stack is deployed.");
+            }
+            return replicaSpecification.map((replica) => ({
+                regionName: replica.regionName,
+                kmsKeyArn: replica.encryptionKey?.keyArn,
+                pointInTimeRecovery: replica.pointInTimeRecovery,
+                propagateTags: replica.propagateTags,
+            }));
+        }
+        if (!regions || regions.length === 0)
+            return undefined;
+        if (!cdktf_1.Token.isUnresolved(this.stack.region) &&
+            regions.includes(this.stack.region)) {
+            // throw new ValidationError(
+            throw new Error("`replicationRegions` cannot include the region where this stack is deployed.");
+        }
+        return [...new Set(regions)].map((region) => ({
+            regionName: region,
+        }));
+    }
+    get hasIndex() {
+        return (this.globalSecondaryIndexesInternal.length +
+            this.localSecondaryIndexesInternal.length >
+            0);
+    }
+    parseEncryption(props) {
+        let encryptionType = props.encryption;
+        if (encryptionType != null && props.serverSideEncryption != null) {
+            // throw new ValidationError(
+            throw new Error("Only one of encryption and serverSideEncryption can be specified, but both were provided");
+        }
+        if (props.serverSideEncryption && props.encryptionKey) {
+            // throw new ValidationError(
+            throw new Error("encryptionKey cannot be specified when serverSideEncryption is specified. Use encryption instead");
+        }
+        if (encryptionType === undefined) {
+            encryptionType =
+                props.encryptionKey != null
+                    ? shared_1.TableEncryption.CUSTOMER_MANAGED
+                    : props.serverSideEncryption
+                        ? shared_1.TableEncryption.AWS_MANAGED
+                        : undefined;
+        }
+        if (encryptionType !== shared_1.TableEncryption.CUSTOMER_MANAGED &&
+            props.encryptionKey) {
+            // throw new ValidationError(
+            throw new Error(`encryptionKey cannot be specified unless encryption is set to TableEncryption.CUSTOMER_MANAGED (it was set to ${encryptionType})`);
+        }
+        // in this case, each replica should specify a Customer KMS key.
+        if (encryptionType === shared_1.TableEncryption.CUSTOMER_MANAGED &&
+            props.replicationRegions) {
+            // throw new ValidationError(
+            throw new Error("TableEncryption.CUSTOMER_MANAGED is not supported by DynamoDB Global Tables (where replicationRegions was set)");
+        }
+        if (props.replicaSpecification &&
+            props.replicaSpecification.length > 0 &&
+            encryptionType === shared_1.TableEncryption.CUSTOMER_MANAGED) {
+            if (props.replicaSpecification.some((replica) => !replica.encryptionKey)) {
+                // throw new ValidationError(
+                throw new Error("When using replicaSpecification, each replica must specify an encryptionKey if TableEncryption.CUSTOMER_MANAGED is used");
+            }
+            //Validate that the keys belong to the correct regions
+            if (props.replicaSpecification.some((replica) => replica.encryptionKey &&
+                replica.encryptionKey.env.region !== replica.regionName)) {
+                // throw new ValidationError(
+                throw new Error("When using replicaSpecification, each replica's encryptionKey must be in the same region as its replica");
+            }
+        }
+        switch (encryptionType) {
+            case shared_1.TableEncryption.CUSTOMER_MANAGED:
+                const key = props.encryptionKey ??
+                    new kms.Key(this, "Key", {
+                        description: `Customer-managed key auto-created for encrypting DynamoDB table at ${this.node.path}`,
+                        enableKeyRotation: true,
+                    });
+                return {
+                    sseSpecification: { enabled: true, kmsKeyArn: key.keyArn },
+                    encryptionKey: key,
+                };
+            case shared_1.TableEncryption.AWS_MANAGED:
+                return { sseSpecification: { enabled: true } }; // Uses alias/aws/dynamodb by default
+            case shared_1.TableEncryption.DEFAULT:
+                return { sseSpecification: { enabled: false } }; // AWS-owned key
+            case undefined:
+                return { sseSpecification: undefined }; // Defaults to AWS-owned key
+            default:
+                // throw new ValidationError(
+                throw new Error(`Unexpected 'encryptionType': ${encryptionType}`);
+        }
+    }
+    renderImportSourceSpecification(importSource) {
+        if (!importSource)
+            return undefined;
+        const renderedInputFormat = importSource.inputFormat._render();
+        return {
+            inputFormat: renderedInputFormat.inputFormat,
+            inputFormatOptions: renderedInputFormat.inputFormatOptions,
+            inputCompressionType: importSource.compressionType,
+            s3BucketSource: {
+                bucket: importSource.bucket.bucketName,
+                bucketOwner: importSource.bucketOwner,
+                keyPrefix: importSource.keyPrefix,
+            },
+        };
+    }
+}
+exports.Table = Table;
+_c = JSII_RTTI_SYMBOL_1;
+Table[_c] = { fqn: "terraconstructs.aws.storage.Table", version: "0.0.25" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.js","sourceRoot":"","sources":["../../../src/aws/storage/table.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-dynamodb/lib/table.ts\n\nimport {\n  dynamodbContributorInsights,\n  dynamodbKinesisStreamingDestination,\n  dynamodbResourcePolicy,\n  dynamodbTable,\n} from \"@cdktf/provider-aws\";\nimport { Token, Lazy, Annotations } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport * as storage from \".\";\nimport { ArnFormat, AwsConstructBase, AwsConstructProps, AwsStack } from \"..\";\nimport { DynamoDBMetrics } from \"./dynamodb-canned-metrics.generated\";\nimport * as perms from \"./dynamodb-perms\";\nimport {\n  EnableScalingProps,\n  IScalableTableAttribute,\n} from \"./scalable-attribute-api\";\nimport { ScalableTableAttribute } from \"./scalable-table-attribute\";\nimport {\n  Operation,\n  OperationsMetricOptions,\n  SystemErrorsForOperationsMetricOptions,\n  Attribute,\n  BillingMode,\n  ProjectionType,\n  ITable,\n  SecondaryIndexProps,\n  TableClass,\n  LocalSecondaryIndexProps,\n  TableEncryption,\n  StreamViewType,\n  PointInTimeRecoverySpecification,\n} from \"./shared\";\nimport * as cloudwatch from \"../cloudwatch\";\nimport * as appscaling from \"../compute\";\nimport * as kms from \"../encryption\";\nimport * as iam from \"../iam\";\nimport * as kinesis from \"../notify\";\n// Missing in Terraform DynamoDb Replica Configuration block\n// https://registry.terraform.io/providers/hashicorp/aws/5.88.0/docs/resources/dynamodb_table#replica\n// import { Duration } from \"../../duration\";\n\n// TODO Adopt UnscopedValidationError, ValidationError when available:\n// - https://github.com/aws/aws-cdk/pull/33382/\n// - https://github.com/aws/aws-cdk/pull/33045\n// import {\n//   UnscopedValidationError,\n//   ValidationError,\n// } from \"../../core/lib/errors\";\n\nconst HASH_KEY_TYPE = \"HASH\";\nconst RANGE_KEY_TYPE = \"RANGE\";\n\nconst MAX_LOCAL_SECONDARY_INDEX_COUNT = 5;\n\n/**\n * Represents the table schema attributes.\n */\nexport interface SchemaOptions {\n  /**\n   * Partition key attribute definition.\n   */\n  readonly partitionKey: Attribute;\n\n  /**\n   * Sort key attribute definition.\n   *\n   * @default no sort key\n   */\n  readonly sortKey?: Attribute;\n}\n\n/**\n * Type of compression to use for imported data.\n */\nexport enum InputCompressionType {\n  /**\n   * GZIP compression.\n   */\n  GZIP = \"GZIP\",\n\n  /**\n   * ZSTD compression.\n   */\n  ZSTD = \"ZSTD\",\n\n  /**\n   * No compression.\n   */\n  NONE = \"NONE\",\n}\n\n/**\n * The options for imported source files in CSV format.\n */\nexport interface CsvOptions {\n  /**\n   * The delimiter used for separating items in the CSV file being imported.\n   *\n   * Valid delimiters are as follows:\n   * - comma (`,`)\n   * - tab (`\\t`)\n   * - colon (`:`)\n   * - semicolon (`;`)\n   * - pipe (`|`)\n   * - space (` `)\n   *\n   * @default - use comma as a delimiter.\n   */\n  readonly delimiter?: string;\n\n  /**\n   * List of the headers used to specify a common header for all source CSV files being imported.\n   *\n   * **NOTE**: If this field is specified then the first line of each CSV file is treated as data instead of the header.\n   * If this field is not specified the the first line of each CSV file is treated as the header.\n   *\n   * @default - the first line of the CSV file is treated as the header\n   */\n  readonly headerList?: string[];\n}\n\n/**\n * The format of the source data.\n */\nexport abstract class InputFormat {\n  /**\n   * DynamoDB JSON format.\n   */\n  public static dynamoDBJson(): InputFormat {\n    return new (class extends InputFormat {\n      public _render(): Pick<\n        dynamodbTable.DynamodbTableImportTable,\n        \"inputFormat\" | \"inputFormatOptions\"\n      > {\n        return {\n          inputFormat: \"DYNAMODB_JSON\",\n        };\n      }\n    })();\n  }\n\n  /**\n   * Amazon Ion format.\n   */\n  public static ion(): InputFormat {\n    return new (class extends InputFormat {\n      public _render(): Pick<\n        dynamodbTable.DynamodbTableImportTable,\n        \"inputFormat\" | \"inputFormatOptions\"\n      > {\n        return {\n          inputFormat: \"ION\",\n        };\n      }\n    })();\n  }\n\n  /**\n   * CSV format.\n   */\n  public static csv(options?: CsvOptions): InputFormat {\n    if (\n      options?.delimiter &&\n      (!this.validCsvDelimiters.includes(options.delimiter) ||\n        options.delimiter.length !== 1)\n    ) {\n      // throw new UnscopedValidationError(\n      throw new Error(\n        [\n          \"Delimiter must be a single character and one of the following:\",\n          `${this.readableValidCsvDelimiters.join(\", \")},`,\n          `got '${options.delimiter}'`,\n        ].join(\" \"),\n      );\n    }\n\n    return new (class extends InputFormat {\n      public _render(): Pick<\n        dynamodbTable.DynamodbTableImportTable,\n        \"inputFormat\" | \"inputFormatOptions\"\n      > {\n        return {\n          inputFormat: \"CSV\",\n          inputFormatOptions: options\n            ? {\n                csv: {\n                  delimiter: options?.delimiter,\n                  headerList: options?.headerList,\n                },\n              }\n            : undefined,\n        };\n      }\n    })();\n  }\n\n  private static validCsvDelimiters = [\",\", \"\\t\", \":\", \";\", \"|\", \" \"];\n  private static readableValidCsvDelimiters = [\n    \"comma (,)\",\n    \"tab (\\\\t)\",\n    \"colon (:)\",\n    \"semicolon (;)\",\n    \"pipe (|)\",\n    \"space ( )\",\n  ];\n\n  /**\n   * @internal\n   */\n  public abstract _render(): Pick<\n    dynamodbTable.DynamodbTableImportTable,\n    \"inputFormat\" | \"inputFormatOptions\"\n  >;\n}\n\n/**\n *  Properties for importing data from the S3.\n */\nexport interface ImportSourceSpecification {\n  /**\n   * The compression type of the imported data.\n   *\n   * @default InputCompressionType.NONE\n   */\n  readonly compressionType?: InputCompressionType;\n\n  /**\n   * The format of the imported data.\n   */\n  readonly inputFormat: InputFormat;\n\n  /**\n   * The S3 bucket that is being imported from.\n   */\n  readonly bucket: storage.IBucket;\n\n  /**\n   * The account number of the S3 bucket that is being imported from.\n   *\n   * @default - no value\n   */\n  readonly bucketOwner?: string;\n\n  /**\n   * The key prefix shared by all S3 Objects that are being imported.\n   *\n   * @default - no value\n   */\n  readonly keyPrefix?: string;\n}\n\n/**\n * The precision associated with the DynamoDB write timestamps that will be replicated to Kinesis.\n * The default setting for record timestamp precision is microseconds. You can change this setting at any time.\n * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-dynamodb-table-kinesisstreamspecification.html#aws-properties-dynamodb-table-kinesisstreamspecification-properties\n */\nexport enum ApproximateCreationDateTimePrecision {\n  /**\n   * Millisecond precision\n   */\n  MILLISECOND = \"MILLISECOND\",\n\n  /**\n   * Microsecond precision\n   */\n  MICROSECOND = \"MICROSECOND\",\n}\n\nexport interface DynamodbTableReplica {\n  /** (Optional) ARN of the CMK that should be used for the AWS KMS encryption. This argument should only be used if the key is different from the default KMS-managed DynamoDB key, `alias/aws/dynamodb`. **Note:** This attribute will _not_ be populated with the ARN of _default_ keys. */\n  readonly encryptionKey?: kms.IKey;\n  /** (Optional) Whether to enable Point In Time Recovery for the replica. Default is `false`. */\n  readonly pointInTimeRecovery?: boolean;\n  /** (Optional) Whether to propagate the global table's tags to a replica. Default is `false`. Changes to tags only move in one direction: from global (source) to replica. In other words, tag drift on a replica will not trigger an update. Tag or replica changes on the global table, whether from drift or configuration changes, are propagated to replicas. Changing from `true` to `false` on a subsequent `apply` means replica tags are left as they were, unmanaged, not deleted. */\n  readonly propagateTags?: boolean;\n  /** (Required) Region name of the replica. */\n  readonly regionName: string;\n}\n\n/**\n * Properties of a DynamoDB Table\n *\n * Use `TableProps` for all table properties\n */\nexport interface TableOptions extends SchemaOptions {\n  /**\n   * The read capacity for the table. Careful if you add Global Secondary Indexes, as\n   * those will share the table's provisioned throughput.\n   *\n   * Can only be provided if billingMode is Provisioned.\n   *\n   * @default 5\n   */\n  readonly readCapacity?: number;\n  /**\n   * The write capacity for the table. Careful if you add Global Secondary Indexes, as\n   * those will share the table's provisioned throughput.\n   *\n   * Can only be provided if billingMode is Provisioned.\n   *\n   * @default 5\n   */\n  readonly writeCapacity?: number;\n\n  /**\n   * The maximum read request units for the table. Careful if you add Global Secondary Indexes, as\n   * those will share the table's maximum on-demand throughput.\n   *\n   * Can only be provided if billingMode is PAY_PER_REQUEST.\n   *\n   * @default - on-demand throughput is disabled\n   */\n  readonly maxReadRequestUnits?: number;\n  /**\n   * The write request units for the table. Careful if you add Global Secondary Indexes, as\n   * those will share the table's maximum on-demand throughput.\n   *\n   * Can only be provided if billingMode is PAY_PER_REQUEST.\n   *\n   * @default - on-demand throughput is disabled\n   */\n  readonly maxWriteRequestUnits?: number;\n\n  /**\n   * Specify how you are charged for read and write throughput and how you manage capacity.\n   *\n   * @default PROVISIONED if `replicationRegions` is not specified, PAY_PER_REQUEST otherwise\n   */\n  readonly billingMode?: BillingMode;\n\n  // TODO: https://github.com/hashicorp/terraform-provider-aws/issues/43142\n  // readonly warmThroughput?: WarmThroughput;\n\n  /**\n   * Whether point-in-time recovery is enabled.\n   * @deprecated use `pointInTimeRecoverySpecification` instead\n   * @default false - point in time recovery is not enabled.\n   */\n  readonly pointInTimeRecovery?: boolean;\n\n  /**\n   * Whether point-in-time recovery is enabled.\n   *\n   * @default - point in time recovery is not enabled.\n   */\n  readonly pointInTimeRecoverySpecification?: PointInTimeRecoverySpecification;\n\n  /**\n   * Whether server-side encryption with an AWS managed customer master key is enabled.\n   *\n   * This property cannot be set if `encryption` and/or `encryptionKey` is set.\n   *\n   * @default - The table is encrypted with an encryption key managed by DynamoDB, and you are not charged any fee for using it.\n   *\n   * @deprecated This property is deprecated. In order to obtain the same behavior as\n   * enabling this, set the `encryption` property to `TableEncryption.AWS_MANAGED` instead.\n   */\n  readonly serverSideEncryption?: boolean;\n\n  /**\n   * Specify the table class.\n   * @default STANDARD\n   */\n  readonly tableClass?: TableClass;\n\n  /**\n   * Whether server-side encryption with an AWS managed customer master key is enabled.\n   *\n   * This property cannot be set if `serverSideEncryption` is set.\n   *\n   * @default - The table is encrypted with an encryption key managed by DynamoDB, and you are not charged any fee for using it.\n   */\n  readonly encryption?: TableEncryption;\n\n  /**\n   * External KMS key to use for table encryption.\n   *\n   * This property can only be set if `encryption` is set to `TableEncryption.CUSTOMER_MANAGED`.\n   *\n   * @default - If `encryption` is set to `TableEncryption.CUSTOMER_MANAGED` and this\n   * property is undefined, a new KMS key will be created and associated with this table.\n   * If `encryption` and this property are both undefined, then the table is encrypted with\n   * an encryption key managed by DynamoDB, and you are not charged any fee for using it.\n   */\n  readonly encryptionKey?: kms.IKey;\n\n  /**\n   * The name of TTL attribute.\n   * @default - TTL is disabled\n   */\n  readonly timeToLiveAttribute?: string;\n\n  /**\n   * When an item in the table is modified, StreamViewType determines what information\n   * is written to the stream for this table.\n   *\n   * @default - streams are disabled unless `replicationRegions` is specified\n   */\n  readonly stream?: StreamViewType;\n\n  /**\n   * Regions where replica tables will be created\n   *\n   * @deprecated use replicaSpecification instead\n   * @default - no replica tables are created\n   */\n  readonly replicationRegions?: string[];\n\n  /**\n   * The specification for replica tables.\n   */\n  readonly replicaSpecification?: DynamodbTableReplica[];\n\n  // readonly replicationTimeout?: Duration; // Not directly applicable to TF's replica block configuration\n\n  /**\n   * Whether CloudWatch contributor insights is enabled.\n   *\n   * @default false\n   */\n  readonly contributorInsightsEnabled?: boolean;\n\n  /**\n   * Enables deletion protection for the table.\n   *\n   * @default false\n   */\n  readonly deletionProtection?: boolean;\n\n  /**\n   * The properties of data being imported from the S3 bucket source to the table.\n   *\n   * @default - no data import from the S3 bucket\n   */\n  readonly importSource?: ImportSourceSpecification;\n\n  /**\n   * Resource policy to assign to table.\n   * Note: `aws_dynamodb_table` does not directly support a resource policy property.\n   * This policy would need to be managed and applied separately, e.g., via `aws_iam_policy` attached to principals.\n   * @default - No resource policy statement\n   */\n  readonly resourcePolicy?: iam.PolicyDocument;\n}\n\n/**\n * Properties for a DynamoDB Table\n */\nexport interface TableProps extends TableOptions, AwsConstructProps {\n  /**\n   * Enforces a particular physical table name.\n   * @default <generated>\n   */\n  readonly tableName?: string;\n\n  /**\n   * Kinesis Data Stream to capture item-level changes for the table.\n   *\n   * @default - no Kinesis Data Stream\n   */\n  readonly kinesisStream?: kinesis.IStream;\n\n  /**\n   * Kinesis Data Stream approximate creation timestamp precision\n   *\n   * @default ApproximateCreationDateTimePrecision.MICROSECOND\n   */\n  readonly kinesisPrecisionTimestamp?: ApproximateCreationDateTimePrecision;\n}\n\n/**\n * Properties for a global secondary index\n */\nexport interface GlobalSecondaryIndexProps\n  extends SecondaryIndexProps,\n    SchemaOptions {\n  /**\n   * The read capacity for the global secondary index.\n   *\n   * Can only be provided if table billingMode is Provisioned or undefined.\n   *\n   * @default 5\n   */\n  readonly readCapacity?: number;\n\n  /**\n   * The write capacity for the global secondary index.\n   *\n   * Can only be provided if table billingMode is Provisioned or undefined.\n   *\n   * @default 5\n   */\n  readonly writeCapacity?: number;\n\n  /**\n   * The maximum read request units for the global secondary index.\n   *\n   * Can only be provided if table billingMode is PAY_PER_REQUEST.\n   *\n   * @default - on-demand throughput is disabled\n   */\n  readonly maxReadRequestUnits?: number;\n\n  /**\n   * The maximum write request units for the global secondary index.\n   *\n   * Can only be provided if table billingMode is PAY_PER_REQUEST.\n   *\n   * @default - on-demand throughput is disabled\n   */\n  readonly maxWriteRequestUnits?: number;\n\n  // TODO: https://github.com/hashicorp/terraform-provider-aws/issues/43142\n  // readonly warmThroughput?: WarmThroughput;\n\n  /**\n   * Whether CloudWatch contributor insights is enabled for the specified global secondary index.\n   *\n   * @default false\n   */\n  readonly contributorInsightsEnabled?: boolean;\n}\n\n/**\n * Reference to a dynamodb table.\n */\nexport interface TableAttributes {\n  /**\n   * The ARN of the dynamodb table.\n   * One of this, or `tableName`, is required.\n   *\n   * @default - no table arn\n   */\n  readonly tableArn?: string;\n\n  /**\n   * The table name of the dynamodb table.\n   * One of this, or `tableArn`, is required.\n   *\n   * @default - no table name\n   */\n  readonly tableName?: string;\n\n  /**\n   * The ARN of the table's stream.\n   *\n   * @default - no table stream\n   */\n  readonly tableStreamArn?: string;\n\n  /**\n   * KMS encryption key, if this table uses a customer-managed encryption key.\n   *\n   * @default - no key\n   */\n  readonly encryptionKey?: kms.IKey;\n\n  /**\n   * The name of the global indexes set for this Table.\n   * Note that you need to set either this property,\n   * or `localIndexes`,\n   * if you want methods like grantReadData()\n   * to grant permissions for indexes as well as the table itself.\n   *\n   * @default - no global indexes\n   */\n  readonly globalIndexes?: string[];\n\n  /**\n   * The name of the local indexes set for this Table.\n   * Note that you need to set either this property,\n   * or `globalIndexes`,\n   * if you want methods like grantReadData()\n   * to grant permissions for indexes as well as the table itself.\n   *\n   * @default - no local indexes\n   */\n  readonly localIndexes?: string[];\n\n  /**\n   * If set to true, grant methods always grant permissions for all indexes.\n   * If false is provided, grant methods grant the permissions\n   * only when `globalIndexes` or `localIndexes` is specified.\n   *\n   * @default - false\n   */\n  readonly grantIndexPermissions?: boolean;\n}\n\nexport abstract class TableBase\n  extends AwsConstructBase\n  implements ITable, iam.IAwsConstructWithPolicy\n{\n  public abstract readonly tableArn: string;\n  public abstract readonly tableName: string;\n  public abstract readonly tableStreamArn?: string;\n  public abstract readonly encryptionKey?: kms.IKey;\n  public abstract resourcePolicy?: iam.PolicyDocument;\n\n  protected readonly regionalArns = new Array<string>();\n\n  public get outputs(): Record<string, any> {\n    return {\n      tableArn: this.tableArn,\n      tableName: this.tableName,\n      tableStreamArn: this.tableStreamArn,\n    };\n  }\n\n  public grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant {\n    const resources = [\n      this.tableArn,\n      Lazy.stringValue({\n        produce: () => (this.hasIndex ? `${this.tableArn}/index/*` : undefined),\n      }),\n      ...this.regionalArns,\n      ...this.regionalArns.map((arn) =>\n        Lazy.stringValue({\n          produce: () => (this.hasIndex ? `${arn}/index/*` : undefined),\n        }),\n      ),\n    ];\n\n    return iam.Grant.addToPrincipalOrResource({\n      grantee,\n      actions,\n      resourceArns: resources.filter((r) => r !== undefined),\n      resource: this, // Grant will take the principal from the grantee\n    });\n  }\n\n  public grantStream(grantee: iam.IGrantable, ...actions: string[]): iam.Grant {\n    if (!this.tableStreamArn) {\n      // throw new ValidationError(\n      throw new Error(\n        `DynamoDB Streams must be enabled on the table ${this.node.path}`,\n        // this,\n      );\n    }\n\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions,\n      resourceArns: [this.tableStreamArn],\n      scope: this,\n    });\n  }\n\n  public grantReadData(grantee: iam.IGrantable): iam.Grant {\n    const tableActions = perms.READ_DATA_ACTIONS_TABLE_SAFE.concat(\n      perms.DESCRIBE_TABLE,\n    );\n\n    // If streams are available, also grant stream-specific actions\n    if (this.tableStreamArn) {\n      return this.combinedGrant(grantee, {\n        keyActions: perms.KEY_READ_ACTIONS,\n        tableActions,\n        streamActions: perms.READ_DATA_ACTIONS_STREAM_ONLY,\n      });\n    }\n\n    return this.combinedGrant(grantee, {\n      keyActions: perms.KEY_READ_ACTIONS,\n      tableActions,\n    });\n  }\n\n  public grantTableListStreams(grantee: iam.IGrantable): iam.Grant {\n    if (!this.tableStreamArn) {\n      // throw new ValidationError(\n      throw new Error(\n        `DynamoDB Streams must be enabled on the table ${this.node.path}`,\n        // this,\n      );\n    }\n\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions: [\"dynamodb:ListStreams\"],\n      resourceArns: [\"*\"],\n    });\n  }\n\n  public grantStreamRead(grantee: iam.IGrantable): iam.Grant {\n    this.grantTableListStreams(grantee);\n    return this.combinedGrant(grantee, {\n      keyActions: perms.KEY_READ_ACTIONS,\n      streamActions: perms.READ_STREAM_DATA_ACTIONS,\n    });\n  }\n\n  public grantWriteData(grantee: iam.IGrantable): iam.Grant {\n    const tableActions = perms.WRITE_DATA_ACTIONS.concat(perms.DESCRIBE_TABLE);\n    const keyActions = perms.KEY_READ_ACTIONS.concat(perms.KEY_WRITE_ACTIONS);\n    return this.combinedGrant(grantee, { keyActions, tableActions });\n  }\n\n  public grantReadWriteData(grantee: iam.IGrantable): iam.Grant {\n    const tableActions = perms.READ_DATA_ACTIONS.concat(\n      perms.WRITE_DATA_ACTIONS,\n    ).concat(perms.DESCRIBE_TABLE);\n    const keyActions = perms.KEY_READ_ACTIONS.concat(perms.KEY_WRITE_ACTIONS);\n    return this.combinedGrant(grantee, { keyActions, tableActions });\n  }\n\n  public grantFullAccess(grantee: iam.IGrantable) {\n    const keyActions = perms.KEY_READ_ACTIONS.concat(perms.KEY_WRITE_ACTIONS);\n    return this.combinedGrant(grantee, {\n      keyActions,\n      tableActions: [\"dynamodb:*\"],\n    });\n  }\n\n  public addToResourcePolicy(\n    statement: iam.PolicyStatement,\n  ): iam.AddToResourcePolicyResult {\n    if (!this.resourcePolicy) {\n      // ensure a policy exists and is associated with the table\n      this.resourcePolicy = new iam.PolicyDocument(this, \"Policy\", {\n        statement: [],\n      });\n      new dynamodbResourcePolicy.DynamodbResourcePolicy(\n        this,\n        \"PolicyAttachment\",\n        {\n          policy: this.resourcePolicy.json,\n          resourceArn: this.tableArn,\n        },\n      );\n    }\n    this.resourcePolicy.addStatements(statement);\n    return {\n      statementAdded: true,\n      policyDependable: this,\n    };\n  }\n\n  public metric(\n    metricName: string,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      namespace: \"AWS/DynamoDB\",\n      metricName,\n      dimensionsMap: {\n        TableName: this.tableName,\n      },\n      ...props,\n    }).attachTo(this);\n  }\n\n  public metricConsumedReadCapacityUnits(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return this.cannedMetric(\n      DynamoDBMetrics.consumedReadCapacityUnitsSum,\n      props,\n    );\n  }\n\n  public metricConsumedWriteCapacityUnits(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return this.cannedMetric(\n      DynamoDBMetrics.consumedWriteCapacityUnitsSum,\n      props,\n    );\n  }\n\n  /** @deprecated use `metricSystemErrorsForOperations`. */\n  public metricSystemErrors(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    if (!props?.dimensionsMap?.Operation) {\n      // 'Operation' must be passed because its an operational metric.\n      // throw new ValidationError(\n      throw new Error(\n        \"'Operation' dimension must be passed for the 'SystemErrors' metric.\",\n        // this,\n      );\n    }\n\n    const dimensionsMap = {\n      TableName: this.tableName,\n      ...props?.dimensionsMap,\n    };\n\n    return this.metric(\"SystemErrors\", {\n      statistic: \"sum\",\n      ...props,\n      dimensionsMap,\n    });\n  }\n\n  public metricUserErrors(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    if (props?.dimensionsMap) {\n      // throw new ValidationError(\n      throw new Error(\n        \"'dimensionsMap' is not supported for the 'UserErrors' metric\",\n        // this,\n      );\n    }\n    return this.metric(\"UserErrors\", {\n      statistic: \"sum\",\n      ...props,\n      dimensionsMap: {},\n    });\n  }\n\n  public metricConditionalCheckFailedRequests(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return this.metric(\"ConditionalCheckFailedRequests\", {\n      statistic: \"sum\",\n      ...props,\n    });\n  }\n\n  /** @deprecated Do not use this function. It returns an invalid metric. Use `metricThrottledRequestsForOperation` instead. */\n  public metricThrottledRequests(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return this.metric(\"ThrottledRequests\", { statistic: \"sum\", ...props });\n  }\n\n  public metricSuccessfulRequestLatency(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    if (!props?.dimensionsMap?.Operation) {\n      // throw new ValidationError(\n      throw new Error(\n        \"'Operation' dimension must be passed for the 'SuccessfulRequestLatency' metric.\",\n        // this,\n      );\n    }\n\n    const dimensionsMap = {\n      TableName: this.tableName,\n      Operation: props.dimensionsMap.Operation,\n    };\n\n    return new cloudwatch.Metric({\n      ...DynamoDBMetrics.successfulRequestLatencyAverage(dimensionsMap),\n      ...props,\n      dimensionsMap,\n    }).attachTo(this);\n  }\n\n  public metricThrottledRequestsForOperation(\n    operation: string,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      ...DynamoDBMetrics.throttledRequestsSum({\n        Operation: operation,\n        TableName: this.tableName,\n      }),\n      ...props,\n    }).attachTo(this);\n  }\n\n  public metricThrottledRequestsForOperations(\n    props?: OperationsMetricOptions,\n  ): cloudwatch.IMetric {\n    return this.sumMetricsForOperations(\n      \"ThrottledRequests\",\n      \"Sum of throttled requests across all operations\",\n      props,\n    );\n  }\n\n  public metricSystemErrorsForOperations(\n    props?: SystemErrorsForOperationsMetricOptions,\n  ): cloudwatch.IMetric {\n    return this.sumMetricsForOperations(\n      \"SystemErrors\",\n      \"Sum of errors across all operations\",\n      props,\n    );\n  }\n\n  private sumMetricsForOperations(\n    metricName: string,\n    expressionLabel: string,\n    props?: OperationsMetricOptions,\n  ): cloudwatch.IMetric {\n    if (props?.dimensionsMap?.Operation) {\n      // throw new ValidationError(\n      throw new Error(\n        \"The Operation dimension is not supported. Use the 'operations' property.\",\n        // this,\n      );\n    }\n\n    const operations = props?.operations ?? Object.values(Operation);\n    const values = this.createMetricsForOperations(metricName, operations, {\n      statistic: \"sum\",\n      ...props,\n    });\n\n    return new cloudwatch.MathExpression({\n      expression: `${Object.keys(values).join(\" + \")}`,\n      usingMetrics: { ...values },\n      color: props?.color,\n      label: expressionLabel,\n      period: props?.period,\n    });\n  }\n\n  private createMetricsForOperations(\n    metricName: string,\n    operations: Operation[],\n    props?: cloudwatch.MetricOptions,\n    metricNameMapper?: (op: Operation) => string,\n  ): Record<string, cloudwatch.IMetric> {\n    const metrics: Record<string, cloudwatch.IMetric> = {};\n    const mapper = metricNameMapper ?? ((op) => op.toLowerCase());\n\n    if (props?.dimensionsMap?.Operation) {\n      // throw new ValidationError(\n      throw new Error(\n        \"Invalid properties. Operation dimension is not supported when calculating operational metrics\",\n        // this,\n      );\n    }\n\n    for (const operation of operations) {\n      const metric = this.metric(metricName, {\n        ...props,\n        dimensionsMap: {\n          TableName: this.tableName,\n          Operation: operation,\n          ...props?.dimensionsMap,\n        },\n      });\n\n      const operationMetricName = mapper(operation);\n      const firstChar = operationMetricName.charAt(0);\n\n      if (firstChar === firstChar.toUpperCase()) {\n        // https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/using-metric-math.html#metric-math-syntax\n        // throw new ValidationError(\n        throw new Error(\n          `Mapper generated an illegal operation metric name: ${operationMetricName}. Must start with a lowercase letter`,\n          // this,\n        );\n      }\n      metrics[operationMetricName] = metric;\n    }\n    return metrics;\n  }\n\n  protected abstract get hasIndex(): boolean;\n\n  private combinedGrant(\n    grantee: iam.IGrantable,\n    opts: {\n      keyActions?: string[];\n      tableActions?: string[];\n      streamActions?: string[];\n    },\n  ): iam.Grant {\n    if (this.encryptionKey && opts.keyActions) {\n      this.encryptionKey.grant(grantee, ...opts.keyActions);\n    }\n    if (opts.tableActions) {\n      const resources = [\n        this.tableArn,\n        Lazy.stringValue({\n          produce: () =>\n            this.hasIndex ? `${this.tableArn}/index/*` : undefined,\n        }),\n        ...this.regionalArns,\n        ...this.regionalArns.map((arn) =>\n          Lazy.stringValue({\n            produce: () => (this.hasIndex ? `${arn}/index/*` : undefined),\n          }),\n        ),\n      ];\n      const ret = iam.Grant.addToPrincipalOrResource({\n        grantee,\n        actions: opts.tableActions,\n        resourceArns: resources.filter((r) => r !== undefined),\n        resource: this,\n      });\n      return ret;\n    }\n\n    if (opts.streamActions) {\n      if (!this.tableStreamArn) {\n        // throw new ValidationError(\n        throw new Error(\n          `DynamoDB Streams must be enabled on the table ${this.node.path}`,\n          // this,\n        );\n      }\n      const ret = iam.Grant.addToPrincipalOrResource({\n        grantee,\n        actions: opts.streamActions,\n        resourceArns: [this.tableStreamArn],\n        resource: this,\n      });\n      return ret;\n    }\n    // throw new ValidationError(\n    throw new Error(\n      `Unexpected grant combination, actions must be provided for table or stream.`,\n      // this,\n    );\n  }\n\n  private cannedMetric(\n    fn: (dims: { TableName: string }) => cloudwatch.MetricProps,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      ...fn({ TableName: this.tableName }),\n      ...props,\n    }).attachTo(this);\n  }\n}\n\n/**\n * Provides a DynamoDB table.\n */\nexport class Table extends TableBase {\n  /**\n   * Permits an IAM Principal to list all DynamoDB Streams.\n   * @deprecated Use `#grantTableListStreams` for more granular permission\n   * @param grantee The principal (no-op if undefined)\n   */\n  public static grantListStreams(grantee: iam.IGrantable): iam.Grant {\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions: [\"dynamodb:ListStreams\"],\n      resourceArns: [\"*\"],\n    });\n  }\n\n  /**\n   * Creates a Table construct that represents an external table via table name.\n   *\n   * @param scope The parent creating construct (usually `this`).\n   * @param id The construct's name.\n   * @param tableName The table's name.\n   */\n  public static fromTableName(\n    scope: Construct,\n    id: string,\n    tableName: string,\n  ): ITable {\n    return Table.fromTableAttributes(scope, id, { tableName });\n  }\n\n  /**\n   * Creates a Table construct that represents an external table via table arn.\n   *\n   * @param scope The parent creating construct (usually `this`).\n   * @param id The construct's name.\n   * @param tableArn The table's ARN.\n   */\n  public static fromTableArn(\n    scope: Construct,\n    id: string,\n    tableArn: string,\n  ): ITable {\n    return Table.fromTableAttributes(scope, id, { tableArn });\n  }\n\n  /**\n   * Creates a Table construct that represents an external table.\n   *\n   * @param scope The parent creating construct (usually `this`).\n   * @param id The construct's name.\n   * @param attrs A `TableAttributes` object.\n   */\n  public static fromTableAttributes(\n    scope: Construct,\n    id: string,\n    attrs: TableAttributes,\n  ): ITable {\n    class Import extends TableBase {\n      public readonly tableName: string;\n      public readonly tableArn: string;\n      public readonly tableStreamArn?: string;\n      public readonly encryptionKey?: kms.IKey;\n      public resourcePolicy?: iam.PolicyDocument;\n      protected readonly hasIndex =\n        (attrs.grantIndexPermissions ?? false) ||\n        (attrs.globalIndexes ?? []).length > 0 ||\n        (attrs.localIndexes ?? []).length > 0;\n\n      constructor(\n        props: AwsConstructProps,\n        _tableArn: string,\n        tableName: string,\n        tableStreamArn?: string,\n      ) {\n        super(scope, id, props);\n        this.tableArn = _tableArn;\n        this.tableName = tableName;\n        this.tableStreamArn = tableStreamArn;\n        this.encryptionKey = attrs.encryptionKey;\n      }\n    }\n\n    let name: string;\n    let arn: string;\n    const stack = AwsStack.ofAwsConstruct(scope);\n    if (!attrs.tableName) {\n      if (!attrs.tableArn) {\n        // throw new ValidationError(\n        throw new Error(\n          \"One of tableName or tableArn is required!\",\n          // scope,\n        );\n      }\n      arn = attrs.tableArn;\n      const maybeTableName = stack.splitArn(\n        attrs.tableArn,\n        ArnFormat.SLASH_RESOURCE_NAME,\n      ).resourceName;\n      if (!maybeTableName) {\n        // throw new ValidationError(\n        throw new Error(\n          \"ARN for DynamoDB table must be in the form: arn:<partition>:dynamodb:<region>:<account>:table/<table-name>\",\n          // scope,\n        );\n      }\n      name = maybeTableName;\n    } else {\n      if (attrs.tableArn) {\n        // throw new ValidationError(\n        throw new Error(\n          \"Only one of tableArn or tableName can be provided\",\n          // scope,\n        );\n      }\n      name = attrs.tableName;\n      arn = stack.formatArn({\n        service: \"dynamodb\",\n        resource: \"table\",\n        resourceName: attrs.tableName,\n      });\n    }\n\n    return new Import(\n      { environmentFromArn: arn },\n      arn,\n      name,\n      attrs.tableStreamArn,\n    );\n  }\n\n  public readonly encryptionKey?: kms.IKey;\n\n  /**\n   * Resource policy to assign to DynamoDB Table.\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-dynamodb-table-resourcepolicy.html\n   * @default - No resource policy statements are added to the created table.\n   */\n  public resourcePolicy?: iam.PolicyDocument;\n  public readonly tableArn: string;\n  public readonly tableName: string;\n  public readonly tableStreamArn: string | undefined;\n\n  private readonly attributeDefinitionsInternal =\n    new Array<dynamodbTable.DynamodbTableAttribute>();\n  private readonly globalSecondaryIndexesInternal =\n    new Array<dynamodbTable.DynamodbTableGlobalSecondaryIndex>();\n  private readonly localSecondaryIndexesInternal =\n    new Array<dynamodbTable.DynamodbTableLocalSecondaryIndex>();\n\n  private readonly secondaryIndexSchemas = new Map<string, SchemaOptions>();\n  private readonly nonKeyAttributes = new Set<string>();\n\n  private readonly tablePartitionKey: Attribute;\n  private readonly tableSortKey?: Attribute;\n\n  private readonly billingMode: BillingMode;\n  private readonly tableScaling: ScalableAttributePair = {};\n  private readonly indexScaling = new Map<string, ScalableAttributePair>();\n  // Commenting out scalingRole as Terraform auto-creates service-linked roles\n  // Unlike AWS CDK CloudFormation, Terraform AWS provider's roleArn is optional\n  // and defaults to appropriate service-linked roles when omitted\n  // private readonly scalingRole: iam.IRole;\n\n  private readonly _resource: dynamodbTable.DynamodbTable;\n  private readonly _replicas: dynamodbTable.DynamodbTableReplica[] | undefined;\n\n  constructor(scope: Construct, id: string, props: TableProps) {\n    super(scope, id, props);\n\n    const physicalTableName =\n      props.tableName ?? this.stack.uniqueResourceName(this);\n\n    const { sseSpecification, encryptionKey } = this.parseEncryption(props);\n    this.encryptionKey = encryptionKey;\n\n    const pointInTimeRecovery = this.renderPointInTimeRecovery(props);\n\n    // error if both replicationRegions and replicaSpecification are specified\n    if (props.replicationRegions && props.replicaSpecification) {\n      // throw new ValidationError(\n      throw new Error(\n        \"You cannot specify both `replicationRegions` and `replicaSpecification`\",\n        // this,\n      );\n    }\n\n    let streamSpecification:\n      | {\n          streamEnabled: boolean;\n          streamViewType?: StreamViewType;\n        }\n      | undefined;\n    if (\n      (props.replicationRegions && props.replicationRegions.length > 0) ||\n      (props.replicaSpecification && props.replicaSpecification.length > 0)\n    ) {\n      if (props.stream && props.stream !== StreamViewType.NEW_AND_OLD_IMAGES) {\n        // throw new ValidationError(\n        throw new Error(\n          \"`stream` must be set to `NEW_AND_OLD_IMAGES` when specifying `replicationRegions`\",\n          // this,\n        );\n      }\n      this.billingMode = props.billingMode ?? BillingMode.PAY_PER_REQUEST;\n      streamSpecification = {\n        streamEnabled: true,\n        streamViewType: StreamViewType.NEW_AND_OLD_IMAGES,\n      };\n    } else {\n      this.billingMode = props.billingMode ?? BillingMode.PROVISIONED;\n      if (props.stream) {\n        streamSpecification = {\n          streamEnabled: true,\n          streamViewType: props.stream,\n        };\n      }\n    }\n    this.validateProvisioning(props);\n    this.addKey(props.partitionKey, HASH_KEY_TYPE);\n    this.tablePartitionKey = props.partitionKey;\n    if (props.sortKey) {\n      this.addKey(props.sortKey, RANGE_KEY_TYPE);\n      this.tableSortKey = props.sortKey;\n    }\n\n    this._replicas = this.renderReplicas(\n      props.replicationRegions,\n      props.replicaSpecification,\n    );\n    if (this._replicas && this._replicas.length > 0) {\n      this._replicas.forEach((r) =>\n        // Save regional arns for grantXxx() methods\n        this.regionalArns.push(\n          this.stack.formatArn({\n            region: r.regionName,\n            service: \"dynamodb\",\n            resource: \"table\",\n            resourceName: physicalTableName,\n          }),\n        ),\n      );\n    }\n\n    this._resource = new dynamodbTable.DynamodbTable(this, \"Resource\", {\n      name: physicalTableName,\n      hashKey: this.tablePartitionKey.name,\n      rangeKey: this.tableSortKey?.name,\n      attribute: this.attributeDefinitionsInternal,\n      globalSecondaryIndex: Lazy.anyValue(\n        {\n          produce: () =>\n            this.globalSecondaryIndexesInternal.map(\n              dynamodbTable.dynamodbTableGlobalSecondaryIndexToTerraform,\n            ),\n        },\n        { omitEmptyArray: true },\n      ),\n      localSecondaryIndex: Lazy.anyValue(\n        {\n          produce: () =>\n            this.localSecondaryIndexesInternal.map(\n              dynamodbTable.dynamodbTableLocalSecondaryIndexToTerraform,\n            ),\n        },\n        { omitEmptyArray: true },\n      ),\n      pointInTimeRecovery,\n      billingMode: this.billingMode,\n      readCapacity:\n        this.billingMode === BillingMode.PROVISIONED\n          ? (props.readCapacity ?? 5)\n          : undefined,\n      writeCapacity:\n        this.billingMode === BillingMode.PROVISIONED\n          ? (props.writeCapacity ?? 5)\n          : undefined,\n      onDemandThroughput:\n        this.billingMode === BillingMode.PAY_PER_REQUEST &&\n        (props.maxReadRequestUnits || props.maxWriteRequestUnits)\n          ? {\n              maxReadRequestUnits: props.maxReadRequestUnits,\n              maxWriteRequestUnits: props.maxWriteRequestUnits,\n            }\n          : undefined,\n      serverSideEncryption: sseSpecification,\n      streamEnabled: streamSpecification?.streamEnabled,\n      streamViewType: streamSpecification?.streamViewType,\n      tableClass: props.tableClass,\n      ttl: props.timeToLiveAttribute\n        ? { attributeName: props.timeToLiveAttribute, enabled: true }\n        : undefined,\n      deletionProtectionEnabled: props.deletionProtection,\n      importTable: this.renderImportSourceSpecification(props.importSource),\n      replica: this._replicas,\n      // resourcePolicy: props.resourcePolicy ? { policyDocument: this.stack.toJsonString(props.resourcePolicy.toJSON()) } : undefined, // Not in TF resource\n      // TODO: https://github.com/hashicorp/terraform-provider-aws/issues/43142\n      // warmThroughput: props.warmThroughput ?? undefined, // Not in TF resource\n    });\n\n    this.tableArn = this._resource.arn;\n    this.tableName = this._resource.name;\n    this.tableStreamArn = streamSpecification?.streamEnabled\n      ? this._resource.streamArn\n      : undefined;\n    this.resourcePolicy = props.resourcePolicy;\n    if (this.resourcePolicy) {\n      new dynamodbResourcePolicy.DynamodbResourcePolicy(\n        this,\n        \"ResourcePolicy\",\n        {\n          policy: this.resourcePolicy.json,\n          resourceArn: this.tableArn,\n        },\n      );\n    }\n\n    if (props.kinesisStream) {\n      new dynamodbKinesisStreamingDestination.DynamodbKinesisStreamingDestination(\n        this,\n        \"KinesisStreamingDestination\",\n        {\n          tableName: this.tableName,\n          streamArn: props.kinesisStream.streamArn,\n          ...(props.kinesisPrecisionTimestamp && {\n            approximateCreationDateTimePrecision:\n              props.kinesisPrecisionTimestamp,\n          }),\n        },\n      );\n    }\n\n    if (props.contributorInsightsEnabled) {\n      // TODO: Generate conntributor insights per Global Secondary Index\n      // this.globalSecondaryIndexesInternal\n      new dynamodbContributorInsights.DynamodbContributorInsights(\n        this,\n        \"ContributorInsights\",\n        {\n          tableName: this.tableName,\n          // TODO: use for each on gli iterator\n          // indexName: iterator.value,\n        },\n      );\n    }\n\n    // Commenting out scalingRole initialization - let Terraform auto-create service-linked role\n    // this.scalingRole = this.makeScalingRole();\n\n    this.node.addValidation({ validate: () => this.validateTable() });\n  }\n\n  public addGlobalSecondaryIndex(props: GlobalSecondaryIndexProps) {\n    this.validateProvisioningGSI(props);\n    this.validateIndexName(props.indexName);\n\n    const gsiProjection = this.buildIndexProjection(props);\n    this.registerAttribute(props.partitionKey);\n    if (props.sortKey) {\n      this.registerAttribute(props.sortKey);\n    }\n\n    this.globalSecondaryIndexesInternal.push({\n      name: props.indexName,\n      hashKey: props.partitionKey.name,\n      rangeKey: props.sortKey?.name,\n      projectionType: gsiProjection.projectionType,\n      nonKeyAttributes: gsiProjection.nonKeyAttributes,\n      readCapacity:\n        this.billingMode === BillingMode.PROVISIONED\n          ? (props.readCapacity ?? 5)\n          : undefined,\n      writeCapacity:\n        this.billingMode === BillingMode.PROVISIONED\n          ? (props.writeCapacity ?? 5)\n          : undefined,\n      onDemandThroughput:\n        this.billingMode === BillingMode.PAY_PER_REQUEST &&\n        (props.maxReadRequestUnits || props.maxWriteRequestUnits)\n          ? {\n              maxReadRequestUnits: props.maxReadRequestUnits,\n              maxWriteRequestUnits: props.maxWriteRequestUnits,\n            }\n          : undefined,\n      // contributorInsightsEnabled: props.contributorInsightsEnabled, // Not in TF GSI block\n      // warmThroughput: props.warmThroughput, // Not in TF GSI block\n    });\n\n    this.secondaryIndexSchemas.set(props.indexName, {\n      partitionKey: props.partitionKey,\n      sortKey: props.sortKey,\n    });\n    this.indexScaling.set(props.indexName, {});\n  }\n\n  public addLocalSecondaryIndex(props: LocalSecondaryIndexProps) {\n    if (\n      this.localSecondaryIndexesInternal.length >=\n      MAX_LOCAL_SECONDARY_INDEX_COUNT\n    ) {\n      throw new RangeError(\n        `A maximum number of local secondary index per table is ${MAX_LOCAL_SECONDARY_INDEX_COUNT}`,\n      );\n    }\n    this.validateIndexName(props.indexName);\n\n    if (!this.tablePartitionKey) {\n      // throw new ValidationError(\n      throw new Error(\n        \"Table partition key must be defined before adding local secondary index\",\n        // this,\n      );\n    }\n    this.registerAttribute(this.tablePartitionKey);\n    this.registerAttribute(props.sortKey);\n\n    const lsiProjection = this.buildIndexProjection(props);\n\n    this.localSecondaryIndexesInternal.push({\n      name: props.indexName,\n      rangeKey: props.sortKey.name,\n      projectionType: lsiProjection.projectionType,\n      nonKeyAttributes: lsiProjection.nonKeyAttributes,\n    });\n\n    this.secondaryIndexSchemas.set(props.indexName, {\n      partitionKey: this.tablePartitionKey,\n      sortKey: props.sortKey,\n    });\n  }\n\n  public autoScaleReadCapacity(\n    props: EnableScalingProps,\n  ): IScalableTableAttribute {\n    if (this.tableScaling.scalableReadAttribute) {\n      // throw new ValidationError(\n      throw new Error(\n        \"Read AutoScaling already enabled for this table\",\n        // this,\n      );\n    }\n    if (this.billingMode === BillingMode.PAY_PER_REQUEST) {\n      // throw new ValidationError(\n      throw new Error(\n        \"AutoScaling is not available for tables with PAY_PER_REQUEST billing mode\",\n        // this,\n      );\n    }\n\n    return (this.tableScaling.scalableReadAttribute =\n      new ScalableTableAttribute(this, \"ReadScaling\", {\n        serviceNamespace: appscaling.ServiceNamespace.DYNAMODB,\n        resourceId: `table/${this.tableName}`,\n        dimension: \"dynamodb:table:ReadCapacityUnits\",\n        // role: this.scalingRole, // Commenting out - let Terraform use service-linked role\n        ...props,\n      }));\n  }\n\n  public autoScaleWriteCapacity(\n    props: EnableScalingProps,\n  ): IScalableTableAttribute {\n    if (this.tableScaling.scalableWriteAttribute) {\n      // throw new ValidationError(\n      throw new Error(\n        \"Write AutoScaling already enabled for this table\",\n        // this,\n      );\n    }\n    if (this.billingMode === BillingMode.PAY_PER_REQUEST) {\n      // throw new ValidationError(\n      throw new Error(\n        \"AutoScaling is not available for tables with PAY_PER_REQUEST billing mode\",\n        // this,\n      );\n    }\n\n    this.tableScaling.scalableWriteAttribute = new ScalableTableAttribute(\n      this,\n      \"WriteScaling\",\n      {\n        serviceNamespace: appscaling.ServiceNamespace.DYNAMODB,\n        resourceId: `table/${this.tableName}`,\n        dimension: \"dynamodb:table:WriteCapacityUnits\",\n        // role: this.scalingRole, // Commenting out - let Terraform use service-linked role\n        ...props,\n      },\n    );\n    // If there are replicas, they depend on the write scaling policy of the main table.\n    // This is not explicitly modeled in TF but was handled by CustomResource dependencies in CDK.\n    // For TF, this dependency is implicit if the provider handles it, or might need explicit dependsOn if issues arise.\n    return this.tableScaling.scalableWriteAttribute;\n  }\n\n  public autoScaleGlobalSecondaryIndexReadCapacity(\n    indexName: string,\n    props: EnableScalingProps,\n  ): IScalableTableAttribute {\n    if (this.billingMode === BillingMode.PAY_PER_REQUEST) {\n      // throw new ValidationError(\n      throw new Error(\n        \"AutoScaling is not available for tables with PAY_PER_REQUEST billing mode\",\n        // this,\n      );\n    }\n    const attributePair = this.indexScaling.get(indexName);\n    if (!attributePair) {\n      // throw new ValidationError(\n      throw new Error(\n        `No global secondary index with name ${indexName}`,\n        // this,\n      );\n    }\n    if (attributePair.scalableReadAttribute) {\n      // throw new ValidationError(\n      throw new Error(\n        \"Read AutoScaling already enabled for this index\",\n        // this,\n      );\n    }\n\n    return (attributePair.scalableReadAttribute = new ScalableTableAttribute(\n      this,\n      `${indexName}ReadScaling`,\n      {\n        serviceNamespace: appscaling.ServiceNamespace.DYNAMODB,\n        resourceId: `table/${this.tableName}/index/${indexName}`,\n        dimension: \"dynamodb:index:ReadCapacityUnits\",\n        // role: this.scalingRole, // Commenting out - let Terraform use service-linked role\n        ...props,\n      },\n    ));\n  }\n\n  public autoScaleGlobalSecondaryIndexWriteCapacity(\n    indexName: string,\n    props: EnableScalingProps,\n  ): IScalableTableAttribute {\n    if (this.billingMode === BillingMode.PAY_PER_REQUEST) {\n      // throw new ValidationError(\n      throw new Error(\n        \"AutoScaling is not available for tables with PAY_PER_REQUEST billing mode\",\n        // this,\n      );\n    }\n    const attributePair = this.indexScaling.get(indexName);\n    if (!attributePair) {\n      // throw new ValidationError(\n      throw new Error(\n        `No global secondary index with name ${indexName}`,\n        // this,\n      );\n    }\n    if (attributePair.scalableWriteAttribute) {\n      // throw new ValidationError(\n      throw new Error(\n        \"Write AutoScaling already enabled for this index\",\n        // this,\n      );\n    }\n\n    return (attributePair.scalableWriteAttribute = new ScalableTableAttribute(\n      this,\n      `${indexName}WriteScaling`,\n      {\n        serviceNamespace: appscaling.ServiceNamespace.DYNAMODB,\n        resourceId: `table/${this.tableName}/index/${indexName}`,\n        dimension: \"dynamodb:index:WriteCapacityUnits\",\n        // role: this.scalingRole, // Commenting out - let Terraform use service-linked role\n        ...props,\n      },\n    ));\n  }\n\n  public schema(indexName?: string): SchemaOptions {\n    if (!indexName) {\n      return {\n        partitionKey: this.tablePartitionKey,\n        sortKey: this.tableSortKey,\n      };\n    }\n    const schema = this.secondaryIndexSchemas.get(indexName);\n    if (!schema) {\n      // throw new ValidationError(\n      throw new Error(\n        `Cannot find schema for index: ${indexName}. Use 'addGlobalSecondaryIndex' or 'addLocalSecondaryIndex' to add index`,\n        // this,\n      );\n    }\n    return schema;\n  }\n\n  private validateTable(): string[] {\n    const errors = new Array<string>();\n    if (!this.tablePartitionKey) {\n      errors.push(\"A partition key must be specified\");\n    }\n    if (this.localSecondaryIndexesInternal.length > 0 && !this.tableSortKey) {\n      errors.push(\n        \"A sort key of the table must be specified to add local secondary indexes\",\n      );\n    }\n    if (\n      this._replicas &&\n      this._replicas.length > 0 &&\n      this.billingMode === BillingMode.PROVISIONED\n    ) {\n      const writeAutoScaleAttribute = this.tableScaling.scalableWriteAttribute;\n      if (!writeAutoScaleAttribute) {\n        errors.push(\n          \"A global Table that uses PROVISIONED as the billing mode needs auto-scaled write capacity. \" +\n            \"Use the autoScaleWriteCapacity() method to enable it.\",\n        );\n      } else if (!writeAutoScaleAttribute._scalingPolicyCreated) {\n        errors.push(\n          \"A global Table that uses PROVISIONED as the billing mode needs auto-scaled write capacity with a policy. \" +\n            \"Call one of the scaleOn*() methods of the object returned from autoScaleWriteCapacity()\",\n        );\n      }\n    }\n    return errors;\n  }\n\n  private validateProvisioning(props: {\n    readCapacity?: number;\n    writeCapacity?: number;\n  }) {\n    if (this.billingMode === BillingMode.PAY_PER_REQUEST) {\n      if (\n        props.readCapacity !== undefined ||\n        props.writeCapacity !== undefined\n      ) {\n        // throw new ValidationError(\n        throw new Error(\n          \"You cannot provision read and write capacity for a table with PAY_PER_REQUEST billing mode\",\n          // this,\n        );\n      }\n    }\n  }\n\n  private validateProvisioningGSI(props: GlobalSecondaryIndexProps) {\n    if (this.billingMode === BillingMode.PAY_PER_REQUEST) {\n      if (\n        props.readCapacity !== undefined ||\n        props.writeCapacity !== undefined\n      ) {\n        // throw new ValidationError(\n        throw new Error(\n          \"You cannot provision read and write capacity for a GSI with PAY_PER_REQUEST billing mode on the table\",\n          // this,\n        );\n      }\n    }\n  }\n\n  private validateIndexName(indexName: string) {\n    if (this.secondaryIndexSchemas.has(indexName)) {\n      // throw new ValidationError(\n      throw new Error(\n        `A duplicate index name, ${indexName}, is not allowed`,\n        // this,\n      );\n    }\n  }\n\n  private validateNonKeyAttributes(nonKeyAttributes: string[]) {\n    if (this.nonKeyAttributes.size + nonKeyAttributes.length > 100) {\n      throw new RangeError(\n        \"A maximum number of nonKeyAttributes across all of secondary indexes is 100\",\n      );\n    }\n    nonKeyAttributes.forEach((att) => this.nonKeyAttributes.add(att));\n  }\n\n  private renderPointInTimeRecovery(\n    props: TableProps,\n  ): dynamodbTable.DynamodbTablePointInTimeRecovery | undefined {\n    if (\n      props.pointInTimeRecoverySpecification !== undefined &&\n      props.pointInTimeRecovery !== undefined\n    ) {\n      // throw new ValidationError(\n      throw new Error(\n        \"`pointInTimeRecoverySpecification` and `pointInTimeRecovery` are set. Use `pointInTimeRecoverySpecification` only.\",\n        // this,\n      );\n    }\n\n    const spec = props.pointInTimeRecoverySpecification;\n    if (spec?.recoveryPeriodInDays) {\n      // TODO: Upgrade provider to 5.98.0 to support recoveryPeriodInDays\n      Annotations.of(this).addWarning(\n        \"Warning: recoveryPeriodInDays is not supported until provider aws is upgraded to 5.98.0 and will be ignored.\",\n      );\n    }\n\n    const enabled =\n      spec?.pointInTimeRecoveryEnabled ?? props.pointInTimeRecovery;\n    if (enabled === undefined) return undefined;\n    return { enabled };\n  }\n\n  private buildIndexProjection(\n    props: SecondaryIndexProps,\n  ): Pick<\n    dynamodbTable.DynamodbTableGlobalSecondaryIndex,\n    \"projectionType\" | \"nonKeyAttributes\"\n  > {\n    if (\n      props.projectionType === ProjectionType.INCLUDE &&\n      !props.nonKeyAttributes\n    ) {\n      // throw new ValidationError(\n      throw new Error(\n        `Non-key attributes should be specified when using ${ProjectionType.INCLUDE} projection type`,\n        // this,\n      );\n    }\n    if (\n      props.projectionType !== ProjectionType.INCLUDE &&\n      props.nonKeyAttributes\n    ) {\n      // throw new ValidationError(\n      throw new Error(\n        `Non-key attributes should not be specified when not using ${ProjectionType.INCLUDE} projection type`,\n        // this,\n      );\n    }\n    if (props.nonKeyAttributes) {\n      this.validateNonKeyAttributes(props.nonKeyAttributes);\n    }\n    return {\n      projectionType: props.projectionType ?? ProjectionType.ALL,\n      nonKeyAttributes: props.nonKeyAttributes,\n    };\n  }\n\n  // TODO: keyType is unused\n  private addKey(attribute: Attribute, _keyType: string) {\n    const existingAttr = this.attributeDefinitionsInternal.find(\n      (def) => def.name === attribute.name,\n    );\n    if (existingAttr && existingAttr.type !== attribute.type) {\n      // throw new ValidationError(\n      throw new Error(\n        `Unable to specify ${attribute.name} as ${attribute.type} because it was already defined as ${existingAttr.type}`,\n        // this,\n      );\n    }\n    if (!existingAttr) {\n      this.attributeDefinitionsInternal.push({\n        name: attribute.name,\n        type: attribute.type,\n      });\n    }\n    // For the main table, hashKey and rangeKey are set directly on the resource.\n    // For GSIs/LSIs, they are part of their respective blocks.\n  }\n\n  private registerAttribute(attribute: Attribute) {\n    const existingDef = this.attributeDefinitionsInternal.find(\n      (def) => def.name === attribute.name,\n    );\n    if (existingDef && existingDef.type !== attribute.type) {\n      // throw new ValidationError(\n      throw new Error(\n        `Unable to specify ${attribute.name} as ${attribute.type} because it was already defined as ${existingDef.type}`,\n        // this,\n      );\n    }\n    if (!existingDef) {\n      this.attributeDefinitionsInternal.push({\n        name: attribute.name,\n        type: attribute.type,\n      });\n    }\n  }\n\n  // Commenting out makeScalingRole method - Terraform handles service-linked roles automatically\n  // Unlike AWS CDK CloudFormation implementation, Terraform AWS provider creates appropriate\n  // service-linked roles when roleArn is omitted from aws_appautoscaling_target resource\n  // private makeScalingRole(): iam.IRole {\n  //   // Use a Service Linked Role.\n  //   // https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html\n  //   return iam.Role.fromRoleArn(\n  //     this,\n  //     \"ScalingRole\",\n  //     this.stack.formatArn({\n  //       service: \"iam\",\n  //       region: \"\", // SLRs are global\n  //       resource:\n  //         \"role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com\",\n  //       resourceName: \"AWSServiceRoleForApplicationAutoScaling_DynamoDBTable\",\n  //       // TODO: Is this needed?\n  //       // arnFormat: ArnFormat.SLASH_RESOURCE_SLASH_RESOURCE_NAME, // Special format for SLRs\n  //     }),\n  //   );\n  // }\n\n  /**\n   * Creates replica tables\n   *\n   * @param regions regions where to create tables\n   */\n  private renderReplicas(\n    regions?: string[],\n    replicaSpecification?: DynamodbTableReplica[],\n  ): dynamodbTable.DynamodbTableReplica[] | undefined {\n    if (replicaSpecification && replicaSpecification.length > 0) {\n      if (\n        !Token.isUnresolved(this.stack.region) &&\n        replicaSpecification.some(\n          (replica) => replica.regionName === this.stack.region,\n        )\n      ) {\n        // throw new ValidationError(\n        throw new Error(\n          \"`replicaSpecification` cannot include the region where this stack is deployed.\",\n          // this,\n        );\n      }\n      return replicaSpecification.map((replica) => ({\n        regionName: replica.regionName,\n        kmsKeyArn: replica.encryptionKey?.keyArn,\n        pointInTimeRecovery: replica.pointInTimeRecovery,\n        propagateTags: replica.propagateTags,\n      }));\n    }\n    if (!regions || regions.length === 0) return undefined;\n\n    if (\n      !Token.isUnresolved(this.stack.region) &&\n      regions.includes(this.stack.region)\n    ) {\n      // throw new ValidationError(\n      throw new Error(\n        \"`replicationRegions` cannot include the region where this stack is deployed.\",\n        // this,\n      );\n    }\n\n    return [...new Set(regions)].map((region) => ({\n      regionName: region,\n    }));\n  }\n\n  protected get hasIndex(): boolean {\n    return (\n      this.globalSecondaryIndexesInternal.length +\n        this.localSecondaryIndexesInternal.length >\n      0\n    );\n  }\n\n  private parseEncryption(props: TableProps): {\n    sseSpecification?: dynamodbTable.DynamodbTableServerSideEncryption;\n    encryptionKey?: kms.IKey;\n  } {\n    let encryptionType = props.encryption;\n    if (encryptionType != null && props.serverSideEncryption != null) {\n      // throw new ValidationError(\n      throw new Error(\n        \"Only one of encryption and serverSideEncryption can be specified, but both were provided\",\n        // this,\n      );\n    }\n    if (props.serverSideEncryption && props.encryptionKey) {\n      // throw new ValidationError(\n      throw new Error(\n        \"encryptionKey cannot be specified when serverSideEncryption is specified. Use encryption instead\",\n        // this,\n      );\n    }\n\n    if (encryptionType === undefined) {\n      encryptionType =\n        props.encryptionKey != null\n          ? TableEncryption.CUSTOMER_MANAGED\n          : props.serverSideEncryption\n            ? TableEncryption.AWS_MANAGED\n            : undefined;\n    }\n\n    if (\n      encryptionType !== TableEncryption.CUSTOMER_MANAGED &&\n      props.encryptionKey\n    ) {\n      // throw new ValidationError(\n      throw new Error(\n        `encryptionKey cannot be specified unless encryption is set to TableEncryption.CUSTOMER_MANAGED (it was set to ${encryptionType})`,\n        // this,\n      );\n    }\n\n    // in this case, each replica should specify a Customer KMS key.\n    if (\n      encryptionType === TableEncryption.CUSTOMER_MANAGED &&\n      props.replicationRegions\n    ) {\n      // throw new ValidationError(\n      throw new Error(\n        \"TableEncryption.CUSTOMER_MANAGED is not supported by DynamoDB Global Tables (where replicationRegions was set)\",\n        // this,\n      );\n    }\n\n    if (\n      props.replicaSpecification &&\n      props.replicaSpecification.length > 0 &&\n      encryptionType === TableEncryption.CUSTOMER_MANAGED\n    ) {\n      if (\n        props.replicaSpecification.some(\n          (replica) => !replica.encryptionKey, // Check if any replica is missing an encryption key\n        )\n      ) {\n        // throw new ValidationError(\n        throw new Error(\n          \"When using replicaSpecification, each replica must specify an encryptionKey if TableEncryption.CUSTOMER_MANAGED is used\",\n          // this,\n        );\n      }\n\n      //Validate that the keys belong to the correct regions\n      if (\n        props.replicaSpecification.some(\n          (replica) =>\n            replica.encryptionKey &&\n            replica.encryptionKey.env.region !== replica.regionName,\n        )\n      ) {\n        // throw new ValidationError(\n        throw new Error(\n          \"When using replicaSpecification, each replica's encryptionKey must be in the same region as its replica\",\n          // this,\n        );\n      }\n    }\n\n    switch (encryptionType) {\n      case TableEncryption.CUSTOMER_MANAGED:\n        const key =\n          props.encryptionKey ??\n          new kms.Key(this, \"Key\", {\n            description: `Customer-managed key auto-created for encrypting DynamoDB table at ${this.node.path}`,\n            enableKeyRotation: true,\n          });\n        return {\n          sseSpecification: { enabled: true, kmsKeyArn: key.keyArn },\n          encryptionKey: key,\n        };\n      case TableEncryption.AWS_MANAGED:\n        return { sseSpecification: { enabled: true } }; // Uses alias/aws/dynamodb by default\n      case TableEncryption.DEFAULT:\n        return { sseSpecification: { enabled: false } }; // AWS-owned key\n      case undefined:\n        return { sseSpecification: undefined }; // Defaults to AWS-owned key\n      default:\n        // throw new ValidationError(\n        throw new Error(\n          `Unexpected 'encryptionType': ${encryptionType}`,\n          // this,\n        );\n    }\n  }\n\n  private renderImportSourceSpecification(\n    importSource?: ImportSourceSpecification,\n  ): dynamodbTable.DynamodbTableImportTable | undefined {\n    if (!importSource) return undefined;\n    const renderedInputFormat = importSource.inputFormat._render();\n    return {\n      inputFormat: renderedInputFormat.inputFormat,\n      inputFormatOptions: renderedInputFormat.inputFormatOptions,\n      inputCompressionType: importSource.compressionType,\n      s3BucketSource: {\n        bucket: importSource.bucket.bucketName,\n        bucketOwner: importSource.bucketOwner,\n        keyPrefix: importSource.keyPrefix,\n      },\n    };\n  }\n}\n\ninterface ScalableAttributePair {\n  scalableReadAttribute?: ScalableTableAttribute;\n  scalableWriteAttribute?: ScalableTableAttribute;\n}\n"]}