terraconstructs 0.0.10 → 0.0.12

package/lib/aws/storage/parameter.js

@@ -0,0 +1,606 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringListParameter = exports.StringParameter = exports.ParameterTier = exports.ParameterDataType = exports.ParameterType = exports.ParameterValueType = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ssm/lib/parameter.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const parameter_util_1 = require("./parameter-util");
+const terra_func_1 = require("../../terra-func");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+const iam = require("../iam");
+/**
+ * Basic features shared across all types of SSM Parameters.
+ */
+class ParameterBase extends aws_construct_1.AwsConstructBase {
+    get parameterOutputs() {
+        return {
+            parameterArn: this.parameterArn,
+            parameterName: this.parameterName,
+            parameterType: this.parameterType,
+        };
+    }
+    get outputs() {
+        return this.parameterOutputs;
+    }
+    grantRead(grantee) {
+        if (this.encryptionKey) {
+            this.encryptionKey.grantDecrypt(grantee);
+        }
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions: [
+                "ssm:DescribeParameters",
+                "ssm:GetParameters",
+                "ssm:GetParameter",
+                "ssm:GetParameterHistory",
+            ],
+            resourceArns: [this.parameterArn],
+        });
+    }
+    grantWrite(grantee) {
+        if (this.encryptionKey) {
+            this.encryptionKey.grantEncrypt(grantee);
+        }
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions: ["ssm:PutParameter"],
+            resourceArns: [this.parameterArn],
+        });
+    }
+}
+/**
+ * The type of CFN SSM Parameter
+ *
+ * Using specific types can be helpful in catching invalid values
+ * at the start of creating or updating a stack. CloudFormation validates
+ * the values against existing values in the account.
+ *
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html#aws-ssm-parameter-types
+ */
+var ParameterValueType;
+(function (ParameterValueType) {
+    /**
+     * String
+     */
+    ParameterValueType["STRING"] = "String";
+    /**
+     * An Availability Zone, such as us-west-2a.
+     */
+    ParameterValueType["AWS_EC2_AVAILABILITYZONE_NAME"] = "AWS::EC2::AvailabilityZone::Name";
+    /**
+     * An Amazon EC2 image ID, such as ami-0ff8a91507f77f867.
+     */
+    ParameterValueType["AWS_EC2_IMAGE_ID"] = "AWS::EC2::Image::Id";
+    /**
+     * An Amazon EC2 instance ID, such as i-1e731a32.
+     */
+    ParameterValueType["AWS_EC2_INSTANCE_ID"] = "AWS::EC2::Instance::Id";
+    /**
+     * An Amazon EC2 key pair name.
+     */
+    ParameterValueType["AWS_EC2_KEYPAIR_KEYNAME"] = "AWS::EC2::KeyPair::KeyName";
+    /**
+     * An EC2-Classic or default VPC security group name, such as my-sg-abc.
+     */
+    ParameterValueType["AWS_EC2_SECURITYGROUP_GROUPNAME"] = "AWS::EC2::SecurityGroup::GroupName";
+    /**
+     * A security group ID, such as sg-a123fd85.
+     */
+    ParameterValueType["AWS_EC2_SECURITYGROUP_ID"] = "AWS::EC2::SecurityGroup::Id";
+    /**
+     * A subnet ID, such as subnet-123a351e.
+     */
+    ParameterValueType["AWS_EC2_SUBNET_ID"] = "AWS::EC2::Subnet::Id";
+    /**
+     * An Amazon EBS volume ID, such as vol-3cdd3f56.
+     */
+    ParameterValueType["AWS_EC2_VOLUME_ID"] = "AWS::EC2::Volume::Id";
+    /**
+     * A VPC ID, such as vpc-a123baa3.
+     */
+    ParameterValueType["AWS_EC2_VPC_ID"] = "AWS::EC2::VPC::Id";
+    /**
+     * An Amazon Route 53 hosted zone ID, such as Z23YXV4OVPL04A.
+     */
+    ParameterValueType["AWS_ROUTE53_HOSTEDZONE_ID"] = "AWS::Route53::HostedZone::Id";
+})(ParameterValueType || (exports.ParameterValueType = ParameterValueType = {}));
+// Deprecated - see https://github.com/aws/aws-cdk/issues/6039
+/**
+ * SSM parameter type
+ * @deprecated these types are no longer used
+ */
+var ParameterType;
+(function (ParameterType) {
+    /**
+     * String
+     */
+    ParameterType["STRING"] = "String";
+    /**
+     * Secure String
+     *
+     * Parameter Store uses an AWS Key Management Service (KMS) customer master key (CMK) to encrypt the parameter value.
+     * Parameters of type SecureString cannot be created directly from a CDK application due to CFN limitations.
+     *
+     * NOTE: Terraform does not prevent creating SecureString parameters, but it is not recommended
+     * because the value will be stored in plain text in the state file.
+     */
+    ParameterType["SECURE_STRING"] = "SecureString";
+    /**
+     * String List
+     */
+    ParameterType["STRING_LIST"] = "StringList";
+    /**
+     * An Amazon EC2 image ID, such as ami-0ff8a91507f77f867
+     */
+    ParameterType["AWS_EC2_IMAGE_ID"] = "AWS::EC2::Image::Id";
+})(ParameterType || (exports.ParameterType = ParameterType = {}));
+/**
+ * SSM parameter data type
+ */
+var ParameterDataType;
+(function (ParameterDataType) {
+    /**
+     * Text
+     */
+    ParameterDataType["TEXT"] = "text";
+    /**
+     * Aws Ec2 Image
+     */
+    ParameterDataType["AWS_EC2_IMAGE"] = "aws:ec2:image";
+})(ParameterDataType || (exports.ParameterDataType = ParameterDataType = {}));
+/**
+ * SSM parameter tier
+ */
+var ParameterTier;
+(function (ParameterTier) {
+    /**
+     * String
+     */
+    ParameterTier["ADVANCED"] = "Advanced";
+    /**
+     * String
+     */
+    ParameterTier["INTELLIGENT_TIERING"] = "Intelligent-Tiering";
+    /**
+     * String
+     */
+    ParameterTier["STANDARD"] = "Standard";
+})(ParameterTier || (exports.ParameterTier = ParameterTier = {}));
+/**
+ * Creates a new String SSM Parameter.
+ * @resource aws_ssm_parameter
+ *
+ * @example
+ * const ssmParameter = new storage.StringParameter(this, 'mySsmParameter', {
+ *    parameterName: 'mySsmParameter',
+ *    stringValue: 'mySsmParameterValue',
+ * });
+ */
+class StringParameter extends ParameterBase {
+    /**
+     * Imports an external string parameter by name.
+     */
+    static fromStringParameterName(scope, id, stringParameterName) {
+        return this.fromStringParameterAttributes(scope, id, {
+            parameterName: stringParameterName,
+        });
+    }
+    /**
+     * Imports an external string parameter by ARN.
+     *
+     * The unencrypted value of a SecureString will be stored in the raw state as plain-text.
+     * [Read more about sensitive data in state](https://www.terraform.io/docs/state/sensitive-data.html).
+     */
+    static fromStringParameterArn(scope, id, stringParameterArn) {
+        if (cdktf_1.Token.isUnresolved(stringParameterArn)) {
+            throw new Error("stringParameterArn cannot be an unresolved token");
+        }
+        // has to be the same region
+        // split the arn string to get the region string
+        // arn sample: arn:aws:ssm:us-east-1:123456789012:parameter/dummyName
+        const arnParts = stringParameterArn.split(":");
+        const stackRegion = aws_stack_1.AwsStack.ofAwsConstruct(scope).region;
+        if (arnParts.length !== 6) {
+            throw new Error("unexpected StringParameterArn format");
+        }
+        else if (cdktf_1.Token.isUnresolved(stackRegion)) {
+            // Region is unknown during synthesis, emit a warning for visibility
+            // "aws-cdk-lib/aws-ssm:crossAccountReferenceSameRegion",
+            cdktf_1.Annotations.of(scope).addWarning("Cross-account references will only work within the same region");
+        }
+        else if (!cdktf_1.Token.isUnresolved(stackRegion) &&
+            arnParts[3] !== stackRegion) {
+            // If the region is known, it must match the region specified in the ARN string
+            throw new Error("stringParameterArn must be in the same region as the stack");
+        }
+        const parameterType = ParameterValueType.STRING;
+        const parameterName = stringParameterArn
+            .split("/")
+            .pop()
+            ?.replace(/parameter\/$/, "") ?? "";
+        const dataSource = new provider_aws_1.dataAwsSsmParameter.DataAwsSsmParameter(scope, `${id}.Parameter`, {
+            name: parameterName,
+            // withDecryption defaults to true
+        });
+        class Import extends ParameterBase {
+            constructor() {
+                super(...arguments);
+                this.parameterName = parameterName;
+                this.parameterArn = stringParameterArn;
+                this.parameterType = parameterType;
+                // Use caution: This value is never marked as sensitive.
+                this.stringValue = dataSource.insecureValue;
+            }
+        }
+        return new Import(scope, id);
+    }
+    /**
+     * Imports an external string parameter with name and optional version.
+     */
+    static fromStringParameterAttributes(scope, id, attrs) {
+        if (!attrs.parameterName) {
+            throw new Error("parameterName cannot be an empty string");
+        }
+        if (attrs.type &&
+            ![ParameterType.STRING, ParameterType.AWS_EC2_IMAGE_ID].includes(attrs.type)) {
+            throw new Error(`fromStringParameterAttributes does not support ${attrs.type}. Please use ParameterType.STRING or ParameterType.AWS_EC2_IMAGE_ID`);
+        }
+        // const forceDynamicReference = attrs.forceDynamicReference ?? false;
+        // ref: https://github.com/aws/aws-cdk/blob/v2.143.0/packages/aws-cdk-lib/aws-ssm/lib/parameter.ts#L483
+        // const type = attrs.type ?? attrs.valueType ?? ParameterValueType.STRING;
+        let name;
+        if (attrs.version) {
+            // To query by parameter version, use "Name": "name:version".
+            // https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html#systemsmanager-GetParameter-request-Name
+            name = `${attrs.parameterName}:${cdktf_1.Tokenization.stringifyNumber(attrs.version)}`;
+        }
+        else {
+            name = attrs.parameterName;
+        }
+        const dataSource = new provider_aws_1.dataAwsSsmParameter.DataAwsSsmParameter(scope, `${id}.Parameter`, {
+            name,
+            withDecryption: attrs.withDecryption, // defaults to true
+        });
+        class Import extends ParameterBase {
+            constructor() {
+                super(...arguments);
+                this.parameterName = attrs.parameterName;
+                this.parameterArn = (0, parameter_util_1.arnForParameterName)(this, attrs.parameterName, { simpleName: attrs.simpleName });
+                this.parameterType = ParameterType.STRING; // dataSource.type - instead of token use concrete
+                // Use caution: This value is never marked as sensitive.
+                this.stringValue = dataSource.insecureValue;
+            }
+        }
+        return new Import(scope, id);
+    }
+    /**
+     * Imports a secure string parameter from the SSM parameter store.
+     */
+    static fromSecureStringParameterAttributes(scope, id, attrs) {
+        if (!attrs.parameterName) {
+            throw new Error("parameterName cannot be an empty string");
+        }
+        let name;
+        if (attrs.version) {
+            name = `${attrs.parameterName}:${cdktf_1.Tokenization.stringifyNumber(attrs.version)}`;
+        }
+        else {
+            name = attrs.parameterName;
+        }
+        const resource = new provider_aws_1.dataAwsSsmParameter.DataAwsSsmParameter(scope, `${id}.Parameter`, {
+            name,
+            withDecryption: attrs.withDecryption, // defaults to true
+        });
+        class Import extends ParameterBase {
+            constructor() {
+                super(...arguments);
+                this.parameterName = attrs.parameterName;
+                this.parameterArn = (0, parameter_util_1.arnForParameterName)(this, attrs.parameterName, { simpleName: attrs.simpleName });
+                this.parameterType = ParameterType.SECURE_STRING; // resource.type - instead of token use concrete
+                // value is always marked as sensitive
+                this.stringValue = resource.value;
+                this.encryptionKey = attrs.encryptionKey;
+            }
+        }
+        return new Import(scope, id);
+    }
+    // // TODO: Use Grid as contextProvider
+    // /**
+    //  * Reads the value of an SSM parameter during synthesis through an
+    //  * environmental context provider.
+    //  *
+    //  * Requires that the stack this scope is defined in will have explicit
+    //  * account/region information. Otherwise, it will fail during synthesis.
+    //  *
+    //  * If defaultValue is provided, it will be used as the dummyValue
+    //  * and the ContextProvider will be told NOT to raise an error on synthesis
+    //  * if the SSM Parameter is not found in the account at synth time.
+    //  */
+    // public static valueFromLookup(
+    //   scope: Construct,
+    //   parameterName: string,
+    //   defaultValue?: string,
+    // ): string {
+    //   const value = ContextProvider.getValue(scope, {
+    //     provider: cxschema.ContextProvider.SSM_PARAMETER_PROVIDER,
+    //     props: { parameterName },
+    //     dummyValue: defaultValue || `dummy-value-for-${parameterName}`,
+    //     ignoreErrorOnMissingContext: defaultValue !== undefined,
+    //   }).value;
+    //   return value;
+    // }
+    /**
+     * Returns a token that will resolve (during deployment) to the string value of an SSM string parameter.
+     * @param scope Some scope within a stack
+     * @param parameterName The name of the SSM parameter.
+     * @param version The parameter version (recommended in order to ensure that the value won't change during deployment)
+     */
+    static valueForStringParameter(scope, parameterName, version) {
+        return StringParameter.valueForTypedStringParameterV2(scope, parameterName, ParameterValueType.STRING, version);
+    }
+    /**
+     * Returns a token that will resolve (during deployment) to the string value of an SSM string parameter.
+     * @param scope Some scope within a stack
+     * @param parameterName The name of the SSM parameter.
+     * @param type The type of the SSM parameter.
+     * @param version The parameter version (recommended in order to ensure that the value won't change during deployment)
+     */
+    static valueForTypedStringParameterV2(scope, parameterName, type = ParameterValueType.STRING, version) {
+        const stack = aws_stack_1.AwsStack.of(scope);
+        const id = makeIdentityForImportedValue(parameterName);
+        const exists = stack.node.tryFindChild(id);
+        if (exists) {
+            return exists.stringValue;
+        }
+        return this.fromStringParameterAttributes(stack, id, {
+            parameterName,
+            version,
+            valueType: type,
+        }).stringValue;
+    }
+    /**
+     * Returns a token that will resolve (during deployment) to the string value of an SSM string parameter.
+     * @param scope Some scope within a stack
+     * @param parameterName The name of the SSM parameter.
+     * @param type The type of the SSM parameter.
+     * @param version The parameter version (recommended in order to ensure that the value won't change during deployment)
+     * @deprecated - use valueForTypedStringParameterV2 instead
+     */
+    static valueForTypedStringParameter(scope, parameterName, type = ParameterType.STRING, version) {
+        if (type === ParameterType.STRING_LIST) {
+            throw new Error("valueForTypedStringParameter does not support STRING_LIST, " +
+                "use valueForTypedListParameter instead");
+        }
+        const stack = aws_stack_1.AwsStack.of(scope);
+        const id = makeIdentityForImportedValue(parameterName);
+        const exists = stack.node.tryFindChild(id);
+        if (exists) {
+            return exists.stringValue;
+        }
+        return this.fromStringParameterAttributes(stack, id, {
+            parameterName,
+            version,
+            type,
+        }).stringValue;
+    }
+    /**
+     * Returns a token that will resolve (during deployment)
+     * @param scope Some scope within a stack
+     * @param parameterName The name of the SSM parameter
+     * @param version The parameter version (required for secure strings)
+     * @deprecated Use `SecretValue.ssmSecure()` instead, it will correctly type the imported value as a `SecretValue` and allow importing without version. `SecretValue` lives in the core `aws-cdk-lib` module.
+     */
+    static valueForSecureStringParameter(scope, parameterName, version) {
+        const stack = aws_stack_1.AwsStack.of(scope);
+        const id = makeIdentityForImportedValue(parameterName);
+        const exists = stack.node.tryFindChild(id);
+        if (exists) {
+            return exists.stringValue;
+        }
+        return this.fromSecureStringParameterAttributes(stack, id, {
+            parameterName,
+            version,
+        }).stringValue;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        const parameterName = props.parameterName ||
+            this.stack.uniqueResourceName(this, {
+                prefix: this.gridUUID,
+            });
+        if (props.stringValue && props.sensitiveStringValue) {
+            throw new Error("Cannot specify both 'stringValue' and 'sensitiveStringValue'");
+        }
+        const stringValue = props.stringValue ?? props.sensitiveStringValue;
+        const isSensitive = !!props.sensitiveStringValue;
+        if (!stringValue) {
+            throw new Error("Either 'stringValue' or 'sensitiveStringValue' must be specified");
+        }
+        if (props.allowedPattern) {
+            _assertValidValue(stringValue, props.allowedPattern);
+        }
+        validateParameterName(parameterName);
+        if (props.description && props.description?.length > 1024) {
+            throw new Error("Description cannot be longer than 1024 characters.");
+        }
+        if (props.type && props.type === ParameterType.AWS_EC2_IMAGE_ID) {
+            throw new Error("The type must either be ParameterType.STRING or ParameterType.STRING_LIST. Did you mean to set dataType: ParameterDataType.AWS_EC2_IMAGE instead?");
+        }
+        this.resource = new provider_aws_1.ssmParameter.SsmParameter(this, "Resource", {
+            allowedPattern: props.allowedPattern,
+            description: props.description,
+            name: parameterName,
+            tier: props.tier,
+            type: props.type ?? ParameterType.STRING,
+            dataType: props.dataType,
+            insecureValue: props.stringValue,
+            value: props.sensitiveStringValue,
+        });
+        this.parameterName = this.resource.name;
+        this.parameterArn = (0, parameter_util_1.arnForParameterName)(this, this.parameterName, {
+            physicalName: parameterName,
+            simpleName: props.simpleName,
+        });
+        this.parameterType = this.resource.type;
+        this.stringValue = isSensitive
+            ? this.resource.value
+            : this.resource.insecureValue;
+    }
+}
+exports.StringParameter = StringParameter;
+_a = JSII_RTTI_SYMBOL_1;
+StringParameter[_a] = { fqn: "terraconstructs.aws.storage.StringParameter", version: "0.0.12" };
+/**
+ * Creates a new StringList SSM Parameter.
+ * @resource AWS::SSM::Parameter
+ */
+class StringListParameter extends ParameterBase {
+    /**
+     * Imports an external parameter of type string list.
+     * Returns a token and should not be parsed.
+     */
+    static fromStringListParameterName(scope, id, stringListParameterName) {
+        // ref: dynamic ref
+        // https://github.com/aws/aws-cdk/blob/v2.143.0/packages/aws-cdk-lib/aws-ssm/lib/parameter.ts#L670
+        return StringListParameter.fromListParameterAttributes(scope, id, {
+            parameterName: stringListParameterName,
+        });
+    }
+    /**
+     * Imports an external string list parameter with name and optional version.
+     */
+    static fromListParameterAttributes(scope, id, attrs) {
+        if (!attrs.parameterName) {
+            throw new Error("parameterName cannot be an empty string");
+        }
+        let name;
+        if (attrs.version) {
+            name = `${attrs.parameterName}:${cdktf_1.Tokenization.stringifyNumber(attrs.version)}`;
+        }
+        else {
+            name = attrs.parameterName;
+        }
+        const type = attrs.elementType ?? ParameterValueType.STRING;
+        const valueType = `List<${type}>`;
+        const resource = new provider_aws_1.dataAwsSsmParameter.DataAwsSsmParameter(scope, `${id}.Parameter`, {
+            name,
+            withDecryption: attrs.withDecryption, // defaults to true
+        });
+        class Import extends ParameterBase {
+            constructor() {
+                super(...arguments);
+                this.parameterName = attrs.parameterName;
+                this.parameterArn = (0, parameter_util_1.arnForParameterName)(this, attrs.parameterName, { simpleName: attrs.simpleName });
+                this.parameterType = valueType; // it doesn't really matter what this is since a CfnParameter can only be `String | StringList`
+                this.stringListValue = terra_func_1.Fn.split(",", resource.insecureValue);
+            }
+        }
+        return new Import(scope, id);
+    }
+    /**
+     * Returns a token that will resolve (during deployment) to the list value of an SSM StringList parameter.
+     * @param scope Some scope within a stack
+     * @param parameterName The name of the SSM parameter.
+     * @param type the type of the SSM list parameter
+     * @param version The parameter version (recommended in order to ensure that the value won't change during deployment)
+     */
+    static valueForTypedListParameter(scope, parameterName, type = ParameterValueType.STRING, version) {
+        const stack = aws_stack_1.AwsStack.of(scope);
+        const id = makeIdentityForImportedValue(parameterName);
+        const exists = stack.node.tryFindChild(id);
+        if (exists) {
+            return exists.stringListValue;
+        }
+        return this.fromListParameterAttributes(stack, id, {
+            parameterName,
+            elementType: type,
+            version,
+        }).stringListValue;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        const parameterName = props.parameterName ||
+            this.stack.uniqueResourceName(this, {
+                prefix: this.gridUUID,
+            });
+        if (props.stringListValue && props.sensitiveStringListValue) {
+            throw new Error("Cannot specify both 'stringListValue' and 'sensitiveStringListValue'");
+        }
+        const stringListValue = props.stringListValue ?? props.sensitiveStringListValue;
+        const isSensitive = !!props.sensitiveStringListValue;
+        if (!stringListValue) {
+            throw new Error("Either 'stringListValue' or 'sensitiveStringListValue' must be specified");
+        }
+        if (stringListValue.find((str) => !cdktf_1.Token.isUnresolved(str) && str.indexOf(",") !== -1)) {
+            throw new Error("Values of a StringList SSM Parameter cannot contain the ',' character. Use a string parameter instead.");
+        }
+        if (props.allowedPattern && !cdktf_1.Token.isUnresolved(stringListValue)) {
+            stringListValue.forEach((str) => _assertValidValue(str, props.allowedPattern));
+        }
+        validateParameterName(parameterName);
+        if (props.description && props.description?.length > 1024) {
+            throw new Error("Description cannot be longer than 1024 characters.");
+        }
+        this.resource = new provider_aws_1.ssmParameter.SsmParameter(this, "Resource", {
+            allowedPattern: props.allowedPattern,
+            description: props.description,
+            name: parameterName,
+            tier: props.tier,
+            type: ParameterType.STRING_LIST,
+            insecureValue: props.stringListValue
+                ? terra_func_1.Fn.join(",", props.stringListValue)
+                : undefined,
+            value: props.sensitiveStringListValue
+                ? terra_func_1.Fn.join(",", props.sensitiveStringListValue)
+                : undefined,
+        });
+        this.parameterName = this.resource.name;
+        this.parameterArn = (0, parameter_util_1.arnForParameterName)(this, this.parameterName, {
+            physicalName: parameterName,
+            simpleName: props.simpleName,
+        });
+        this.parameterType = this.resource.type;
+        this.stringListValue = isSensitive
+            ? terra_func_1.Fn.split(",", this.resource.value)
+            : terra_func_1.Fn.split(",", this.resource.insecureValue);
+    }
+}
+exports.StringListParameter = StringListParameter;
+_b = JSII_RTTI_SYMBOL_1;
+StringListParameter[_b] = { fqn: "terraconstructs.aws.storage.StringListParameter", version: "0.0.12" };
+/**
+ * Validates whether a supplied value conforms to the allowedPattern, granted neither is an unresolved token.
+ *
+ * @param value          the value to be validated.
+ * @param allowedPattern the regular expression to use for validation.
+ *
+ * @throws if the ``value`` does not conform to the ``allowedPattern`` and neither is an unresolved token (per
+ *         ``cdk.unresolved``).
+ */
+function _assertValidValue(value, allowedPattern) {
+    if (cdktf_1.Token.isUnresolved(value) || cdktf_1.Token.isUnresolved(allowedPattern)) {
+        // Unable to perform validations against unresolved tokens
+        return;
+    }
+    if (!new RegExp(allowedPattern).test(value)) {
+        throw new Error(`The supplied value (${value}) does not match the specified allowedPattern (${allowedPattern})`);
+    }
+}
+function makeIdentityForImportedValue(parameterName) {
+    return `SsmParameterValue:${parameterName}:C96584B6-F00A-464E-AD19-53AFF4B05118`;
+}
+function validateParameterName(parameterName) {
+    if (cdktf_1.Token.isUnresolved(parameterName)) {
+        return;
+    }
+    if (parameterName.length > 2048) {
+        throw new Error("name cannot be longer than 2048 characters.");
+    }
+    if (!parameterName.match(/^[\/\w.-]+$/)) {
+        throw new Error(`name must only contain letters, numbers, and the following 4 symbols .-_/; got ${parameterName}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parameter.js","sourceRoot":"","sources":["../../../src/aws/storage/parameter.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ssm/lib/parameter.ts\n\nimport { ssmParameter, dataAwsSsmParameter } from \"@cdktf/provider-aws\";\nimport {\n  // CfnDynamicReference,\n  // CfnDynamicReferenceService,\n  // TODO: Use Grid as contextProvider\n  // ContextProvider,\n  Annotations,\n  // Fn,\n  Token,\n  Tokenization,\n  IResolvable,\n} from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { arnForParameterName } from \"./parameter-util\";\nimport { Fn } from \"../../terra-func\";\nimport {\n  IAwsConstruct,\n  AwsConstructBase,\n  AwsConstructProps,\n} from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport * as encryption from \"../encryption\";\nimport * as iam from \"../iam\";\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface ParameterOutputs {\n  /**\n   * The ARN of the SSM Parameter resource.\n   * @attribute\n   */\n  readonly parameterArn: string;\n\n  /**\n   * The name of the SSM Parameter resource.\n   * @attribute\n   */\n  readonly parameterName: string;\n\n  /**\n   * The type of the SSM Parameter resource.\n   * @attribute\n   */\n  readonly parameterType: string;\n}\n\n/**\n * An SSM Parameter reference.\n */\nexport interface IParameter extends IAwsConstruct {\n  /** Strongly typed outputs */\n  readonly parameterOutputs: ParameterOutputs;\n\n  /**\n   * The ARN of the SSM Parameter resource.\n   * @attribute\n   */\n  readonly parameterArn: string;\n\n  /**\n   * The name of the SSM Parameter resource.\n   * @attribute\n   */\n  readonly parameterName: string;\n\n  /**\n   * The type of the SSM Parameter resource.\n   * @attribute\n   */\n  readonly parameterType: string;\n\n  /**\n   * Grants read (DescribeParameter, GetParameters, GetParameter, GetParameterHistory) permissions on the SSM Parameter.\n   *\n   * @param grantee the role to be granted read-only access to the parameter.\n   */\n  grantRead(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Grants write (PutParameter) permissions on the SSM Parameter.\n   *\n   * @param grantee the role to be granted write access to the parameter.\n   */\n  grantWrite(grantee: iam.IGrantable): iam.Grant;\n}\n\n/**\n * A String SSM Parameter.\n */\nexport interface IStringParameter extends IParameter {\n  /**\n   * The parameter value. Value must not nest another parameter. Do not use {{}} in the value.\n   *\n   * @attribute Value\n   */\n  readonly stringValue: string;\n}\n\n/**\n * A StringList SSM Parameter.\n */\nexport interface IStringListParameter extends IParameter {\n  /**\n   * The parameter value. Value must not nest another parameter. Do not use {{}} in the value. Values in the array\n   * cannot contain commas (``,``).\n   *\n   * @attribute Value\n   */\n  readonly stringListValue: string[];\n}\n\n/**\n * Properties needed to create a new SSM Parameter.\n */\nexport interface ParameterOptions extends AwsConstructProps {\n  /**\n   * A regular expression used to validate the parameter value. For example, for String types with values restricted to\n   * numbers, you can specify the following: ``^\\d+$``\n   *\n   * @default no validation is performed\n   */\n  readonly allowedPattern?: string;\n\n  /**\n   * Information about the parameter that you want to add to the system.\n   *\n   * @default none\n   */\n  readonly description?: string;\n\n  /**\n   * The name of the parameter.\n   *\n   * @default - a name will be generated by CloudFormation\n   */\n  readonly parameterName?: string;\n\n  /**\n   * Indicates whether the parameter name is a simple name. A parameter name\n   * without any \"/\" is considered a simple name. If the parameter name includes\n   * \"/\", setting simpleName to true might cause unintended issues such\n   * as duplicate \"/\" in the resulting ARN.\n   *\n   * This is required only if `parameterName` is a token, which means we\n   * are unable to detect if the name is simple or \"path-like\" for the purpose\n   * of rendering SSM parameter ARNs.\n   *\n   * If `parameterName` is not specified, `simpleName` must be `true` (or\n   * undefined) since the name generated by AWS CloudFormation is always a\n   * simple name.\n   *\n   * @default - auto-detect based on `parameterName`\n   */\n  readonly simpleName?: boolean;\n\n  /**\n   * The tier of the string parameter\n   *\n   * @default - undefined\n   */\n  readonly tier?: ParameterTier;\n}\n\n/**\n * Properties needed to create a String SSM parameter.\n */\nexport interface StringParameterProps extends ParameterOptions {\n  /**\n   * The value of the parameter. It may not reference another parameter and ``{{}}`` cannot be used in the value.\n   *\n   * This is never marked as sensitive.\n   *\n   * conflicts with `sensitiveStringValue`\n   */\n  readonly stringValue?: string;\n\n  /**\n   * The value of the parameter always marked as sensitive.\n   *\n   * It may not reference another parameter and ``{{}}`` cannot be used in the value.\n   *\n   * conflicts with `stringValue`\n   */\n  readonly sensitiveStringValue?: string;\n\n  /**\n   * The type of the string parameter\n   *\n   * @default ParameterType.STRING\n   * @deprecated - type will always be 'String'\n   */\n  readonly type?: ParameterType;\n\n  /**\n   * The data type of the parameter, such as `text` or `aws:ec2:image`.\n   *\n   * @default ParameterDataType.TEXT\n   */\n  readonly dataType?: ParameterDataType;\n}\n\n/**\n * Properties needed to create a StringList SSM Parameter\n */\nexport interface StringListParameterProps extends ParameterOptions {\n  /**\n   * The values of the parameter. It may not reference another parameter and ``{{}}`` cannot be used in the value.\n   */\n  readonly stringListValue?: string[];\n\n  /**\n   * The values of the parameter always marked as sensitive.\n   *\n   * It may not reference another parameter and ``{{}}`` cannot be used in the value.\n   *\n   * conflicts with `stringListValue`\n   */\n  readonly sensitiveStringListValue?: string[];\n}\n\n/**\n * Basic features shared across all types of SSM Parameters.\n */\nabstract class ParameterBase extends AwsConstructBase implements IParameter {\n  public abstract readonly parameterArn: string;\n  public abstract readonly parameterName: string;\n  public abstract readonly parameterType: string;\n  public get parameterOutputs(): ParameterOutputs {\n    return {\n      parameterArn: this.parameterArn,\n      parameterName: this.parameterName,\n      parameterType: this.parameterType,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.parameterOutputs;\n  }\n\n  /**\n   * The encryption key that is used to encrypt this parameter.\n   *\n   * @default - default master key\n   */\n  public readonly encryptionKey?: encryption.IKey;\n\n  public grantRead(grantee: iam.IGrantable): iam.Grant {\n    if (this.encryptionKey) {\n      this.encryptionKey.grantDecrypt(grantee);\n    }\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions: [\n        \"ssm:DescribeParameters\",\n        \"ssm:GetParameters\",\n        \"ssm:GetParameter\",\n        \"ssm:GetParameterHistory\",\n      ],\n      resourceArns: [this.parameterArn],\n    });\n  }\n\n  public grantWrite(grantee: iam.IGrantable): iam.Grant {\n    if (this.encryptionKey) {\n      this.encryptionKey.grantEncrypt(grantee);\n    }\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions: [\"ssm:PutParameter\"],\n      resourceArns: [this.parameterArn],\n    });\n  }\n}\n\n/**\n * The type of CFN SSM Parameter\n *\n * Using specific types can be helpful in catching invalid values\n * at the start of creating or updating a stack. CloudFormation validates\n * the values against existing values in the account.\n *\n * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html#aws-ssm-parameter-types\n */\nexport enum ParameterValueType {\n  /**\n   * String\n   */\n  STRING = \"String\",\n\n  /**\n   * An Availability Zone, such as us-west-2a.\n   */\n  AWS_EC2_AVAILABILITYZONE_NAME = \"AWS::EC2::AvailabilityZone::Name\",\n\n  /**\n   * An Amazon EC2 image ID, such as ami-0ff8a91507f77f867.\n   */\n  AWS_EC2_IMAGE_ID = \"AWS::EC2::Image::Id\",\n\n  /**\n   * An Amazon EC2 instance ID, such as i-1e731a32.\n   */\n  AWS_EC2_INSTANCE_ID = \"AWS::EC2::Instance::Id\",\n\n  /**\n   * An Amazon EC2 key pair name.\n   */\n  AWS_EC2_KEYPAIR_KEYNAME = \"AWS::EC2::KeyPair::KeyName\",\n\n  /**\n   * An EC2-Classic or default VPC security group name, such as my-sg-abc.\n   */\n  AWS_EC2_SECURITYGROUP_GROUPNAME = \"AWS::EC2::SecurityGroup::GroupName\",\n\n  /**\n   * A security group ID, such as sg-a123fd85.\n   */\n  AWS_EC2_SECURITYGROUP_ID = \"AWS::EC2::SecurityGroup::Id\",\n\n  /**\n   * A subnet ID, such as subnet-123a351e.\n   */\n  AWS_EC2_SUBNET_ID = \"AWS::EC2::Subnet::Id\",\n\n  /**\n   * An Amazon EBS volume ID, such as vol-3cdd3f56.\n   */\n  AWS_EC2_VOLUME_ID = \"AWS::EC2::Volume::Id\",\n\n  /**\n   * A VPC ID, such as vpc-a123baa3.\n   */\n  AWS_EC2_VPC_ID = \"AWS::EC2::VPC::Id\",\n\n  /**\n   * An Amazon Route 53 hosted zone ID, such as Z23YXV4OVPL04A.\n   */\n  AWS_ROUTE53_HOSTEDZONE_ID = \"AWS::Route53::HostedZone::Id\",\n}\n\n// Deprecated - see https://github.com/aws/aws-cdk/issues/6039\n\n/**\n * SSM parameter type\n * @deprecated these types are no longer used\n */\nexport enum ParameterType {\n  /**\n   * String\n   */\n  STRING = \"String\",\n  /**\n   * Secure String\n   *\n   * Parameter Store uses an AWS Key Management Service (KMS) customer master key (CMK) to encrypt the parameter value.\n   * Parameters of type SecureString cannot be created directly from a CDK application due to CFN limitations.\n   *\n   * NOTE: Terraform does not prevent creating SecureString parameters, but it is not recommended\n   * because the value will be stored in plain text in the state file.\n   */\n  SECURE_STRING = \"SecureString\",\n  /**\n   * String List\n   */\n  STRING_LIST = \"StringList\",\n  /**\n   * An Amazon EC2 image ID, such as ami-0ff8a91507f77f867\n   */\n  AWS_EC2_IMAGE_ID = \"AWS::EC2::Image::Id\",\n}\n\n/**\n * SSM parameter data type\n */\nexport enum ParameterDataType {\n  /**\n   * Text\n   */\n  TEXT = \"text\",\n  /**\n   * Aws Ec2 Image\n   */\n  AWS_EC2_IMAGE = \"aws:ec2:image\",\n}\n\n/**\n * SSM parameter tier\n */\nexport enum ParameterTier {\n  /**\n   * String\n   */\n  ADVANCED = \"Advanced\",\n  /**\n   * String\n   */\n  INTELLIGENT_TIERING = \"Intelligent-Tiering\",\n  /**\n   * String\n   */\n  STANDARD = \"Standard\",\n}\n\n/**\n * Common attributes for string parameters.\n */\nexport interface CommonStringParameterAttributes {\n  /**\n   * The name of the parameter store value.\n   *\n   * This value can be a token or a concrete string. If it is a concrete string\n   * and includes \"/\" it must also be prefixed with a \"/\" (fully-qualified).\n   */\n  readonly parameterName: string;\n\n  /**\n   * Indicates whether the parameter name is a simple name. A parameter name\n   * without any \"/\" is considered a simple name. If the parameter name includes\n   * \"/\", setting simpleName to true might cause unintended issues such\n   * as duplicate \"/\" in the resulting ARN.\n   *\n   * This is required only if `parameterName` is a token, which means we\n   * are unable to detect if the name is simple or \"path-like\" for the purpose\n   * of rendering SSM parameter ARNs.\n   *\n   * If `parameterName` is not specified, `simpleName` must be `true` (or\n   * undefined) since the name generated by AWS CloudFormation is always a\n   * simple name.\n   *\n   * @default - auto-detect based on `parameterName`\n   */\n  readonly simpleName?: boolean;\n\n  /**\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.49.0/docs/data-sources/ssm_parameter#with_decryption DataAwsSsmParameter#with_decryption}\n   *\n   * @default: true\n   */\n  readonly withDecryption?: boolean | IResolvable;\n}\n\n/**\n * Attributes for parameters of various types of string.\n *\n * @see ParameterType\n */\nexport interface StringParameterAttributes\n  extends CommonStringParameterAttributes {\n  /**\n   * The version number of the value you wish to retrieve.\n   *\n   * @default The latest version will be retrieved.\n   */\n  readonly version?: number;\n\n  /**\n   * The type of the string parameter\n   *\n   * @default ParameterType.STRING\n   * @deprecated - use valueType instead\n   */\n  readonly type?: ParameterType;\n\n  /**\n   * The type of the string parameter value\n   *\n   * Using specific types can be helpful in catching invalid values\n   * at the start of creating or updating a stack. CloudFormation validates\n   * the values against existing values in the account.\n   *\n   * Note - if you want to allow values from different AWS accounts, use\n   * ParameterValueType.STRING\n   *\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html#aws-ssm-parameter-types\n   *\n   * @default ParameterValueType.STRING\n   */\n  readonly valueType?: ParameterValueType;\n}\n\n/**\n * Attributes for parameters of string list type.\n *\n * @see ParameterType\n */\nexport interface ListParameterAttributes\n  extends CommonStringParameterAttributes {\n  /**\n   * The version number of the value you wish to retrieve.\n   *\n   * @default The latest version will be retrieved.\n   */\n  readonly version?: number;\n\n  /**\n   * The type of the string list parameter value.\n   *\n   * Using specific types can be helpful in catching invalid values\n   * at the start of creating or updating a stack. CloudFormation validates\n   * the values against existing values in the account.\n   *\n   * Note - if you want to allow values from different AWS accounts, use\n   * ParameterValueType.STRING\n   *\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html#aws-ssm-parameter-types\n   *\n   * @default ParameterValueType.STRING\n   */\n  readonly elementType?: ParameterValueType;\n}\n\n/**\n * Attributes for secure string parameters.\n */\nexport interface SecureStringParameterAttributes\n  extends CommonStringParameterAttributes {\n  /**\n   * The version number of the value you wish to retrieve.\n   *\n   * @default - AWS CloudFormation uses the latest version of the parameter\n   */\n  readonly version?: number;\n\n  /**\n   * The encryption key that is used to encrypt this parameter\n   *\n   * @default - default master key\n   */\n  readonly encryptionKey?: encryption.IKey;\n}\n\n/**\n * Creates a new String SSM Parameter.\n * @resource aws_ssm_parameter\n *\n * @example\n * const ssmParameter = new storage.StringParameter(this, 'mySsmParameter', {\n *    parameterName: 'mySsmParameter',\n *    stringValue: 'mySsmParameterValue',\n * });\n */\nexport class StringParameter extends ParameterBase implements IStringParameter {\n  /**\n   * Imports an external string parameter by name.\n   */\n  public static fromStringParameterName(\n    scope: Construct,\n    id: string,\n    stringParameterName: string,\n  ): IStringParameter {\n    return this.fromStringParameterAttributes(scope, id, {\n      parameterName: stringParameterName,\n    });\n  }\n\n  /**\n   * Imports an external string parameter by ARN.\n   *\n   * The unencrypted value of a SecureString will be stored in the raw state as plain-text.\n   * [Read more about sensitive data in state](https://www.terraform.io/docs/state/sensitive-data.html).\n   */\n  public static fromStringParameterArn(\n    scope: Construct,\n    id: string,\n    stringParameterArn: string,\n  ): IStringParameter {\n    if (Token.isUnresolved(stringParameterArn)) {\n      throw new Error(\"stringParameterArn cannot be an unresolved token\");\n    }\n\n    // has to be the same region\n    // split the arn string to get the region string\n    // arn sample: arn:aws:ssm:us-east-1:123456789012:parameter/dummyName\n    const arnParts = stringParameterArn.split(\":\");\n    const stackRegion = AwsStack.ofAwsConstruct(scope).region;\n    if (arnParts.length !== 6) {\n      throw new Error(\"unexpected StringParameterArn format\");\n    } else if (Token.isUnresolved(stackRegion)) {\n      // Region is unknown during synthesis, emit a warning for visibility\n      // \"aws-cdk-lib/aws-ssm:crossAccountReferenceSameRegion\",\n      Annotations.of(scope).addWarning(\n        \"Cross-account references will only work within the same region\",\n      );\n    } else if (\n      !Token.isUnresolved(stackRegion) &&\n      arnParts[3] !== stackRegion\n    ) {\n      // If the region is known, it must match the region specified in the ARN string\n      throw new Error(\n        \"stringParameterArn must be in the same region as the stack\",\n      );\n    }\n\n    const parameterType = ParameterValueType.STRING;\n\n    const parameterName =\n      stringParameterArn\n        .split(\"/\")\n        .pop()\n        ?.replace(/parameter\\/$/, \"\") ?? \"\";\n    const dataSource = new dataAwsSsmParameter.DataAwsSsmParameter(\n      scope,\n      `${id}.Parameter`,\n      {\n        name: parameterName,\n        // withDecryption defaults to true\n      },\n    );\n    class Import extends ParameterBase {\n      public readonly parameterName = parameterName;\n      public readonly parameterArn = stringParameterArn;\n      public readonly parameterType = parameterType;\n      // Use caution: This value is never marked as sensitive.\n      public readonly stringValue = dataSource.insecureValue;\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * Imports an external string parameter with name and optional version.\n   */\n  public static fromStringParameterAttributes(\n    scope: Construct,\n    id: string,\n    attrs: StringParameterAttributes,\n  ): IStringParameter {\n    if (!attrs.parameterName) {\n      throw new Error(\"parameterName cannot be an empty string\");\n    }\n    if (\n      attrs.type &&\n      ![ParameterType.STRING, ParameterType.AWS_EC2_IMAGE_ID].includes(\n        attrs.type,\n      )\n    ) {\n      throw new Error(\n        `fromStringParameterAttributes does not support ${attrs.type}. Please use ParameterType.STRING or ParameterType.AWS_EC2_IMAGE_ID`,\n      );\n    }\n\n    // const forceDynamicReference = attrs.forceDynamicReference ?? false;\n    // ref: https://github.com/aws/aws-cdk/blob/v2.143.0/packages/aws-cdk-lib/aws-ssm/lib/parameter.ts#L483\n    // const type = attrs.type ?? attrs.valueType ?? ParameterValueType.STRING;\n\n    let name: string;\n    if (attrs.version) {\n      // To query by parameter version, use \"Name\": \"name:version\".\n      // https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html#systemsmanager-GetParameter-request-Name\n      name = `${attrs.parameterName}:${Tokenization.stringifyNumber(attrs.version)}`;\n    } else {\n      name = attrs.parameterName;\n    }\n    const dataSource = new dataAwsSsmParameter.DataAwsSsmParameter(\n      scope,\n      `${id}.Parameter`,\n      {\n        name,\n        withDecryption: attrs.withDecryption, // defaults to true\n      },\n    );\n\n    class Import extends ParameterBase {\n      public readonly parameterName = attrs.parameterName;\n      public readonly parameterArn = arnForParameterName(\n        this,\n        attrs.parameterName,\n        { simpleName: attrs.simpleName },\n      );\n      public readonly parameterType = ParameterType.STRING; // dataSource.type - instead of token use concrete\n      // Use caution: This value is never marked as sensitive.\n      public readonly stringValue = dataSource.insecureValue;\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * Imports a secure string parameter from the SSM parameter store.\n   */\n  public static fromSecureStringParameterAttributes(\n    scope: Construct,\n    id: string,\n    attrs: SecureStringParameterAttributes,\n  ): IStringParameter {\n    if (!attrs.parameterName) {\n      throw new Error(\"parameterName cannot be an empty string\");\n    }\n    let name: string;\n    if (attrs.version) {\n      name = `${attrs.parameterName}:${Tokenization.stringifyNumber(attrs.version)}`;\n    } else {\n      name = attrs.parameterName;\n    }\n    const resource = new dataAwsSsmParameter.DataAwsSsmParameter(\n      scope,\n      `${id}.Parameter`,\n      {\n        name,\n        withDecryption: attrs.withDecryption, // defaults to true\n      },\n    );\n\n    class Import extends ParameterBase {\n      public readonly parameterName = attrs.parameterName;\n      public readonly parameterArn = arnForParameterName(\n        this,\n        attrs.parameterName,\n        { simpleName: attrs.simpleName },\n      );\n      public readonly parameterType = ParameterType.SECURE_STRING; // resource.type - instead of token use concrete\n      // value is always marked as sensitive\n      public readonly stringValue = resource.value;\n      public readonly encryptionKey = attrs.encryptionKey;\n    }\n\n    return new Import(scope, id);\n  }\n\n  // // TODO: Use Grid as contextProvider\n  // /**\n  //  * Reads the value of an SSM parameter during synthesis through an\n  //  * environmental context provider.\n  //  *\n  //  * Requires that the stack this scope is defined in will have explicit\n  //  * account/region information. Otherwise, it will fail during synthesis.\n  //  *\n  //  * If defaultValue is provided, it will be used as the dummyValue\n  //  * and the ContextProvider will be told NOT to raise an error on synthesis\n  //  * if the SSM Parameter is not found in the account at synth time.\n  //  */\n  // public static valueFromLookup(\n  //   scope: Construct,\n  //   parameterName: string,\n  //   defaultValue?: string,\n  // ): string {\n  //   const value = ContextProvider.getValue(scope, {\n  //     provider: cxschema.ContextProvider.SSM_PARAMETER_PROVIDER,\n  //     props: { parameterName },\n  //     dummyValue: defaultValue || `dummy-value-for-${parameterName}`,\n  //     ignoreErrorOnMissingContext: defaultValue !== undefined,\n  //   }).value;\n\n  //   return value;\n  // }\n\n  /**\n   * Returns a token that will resolve (during deployment) to the string value of an SSM string parameter.\n   * @param scope Some scope within a stack\n   * @param parameterName The name of the SSM parameter.\n   * @param version The parameter version (recommended in order to ensure that the value won't change during deployment)\n   */\n  public static valueForStringParameter(\n    scope: Construct,\n    parameterName: string,\n    version?: number,\n  ): string {\n    return StringParameter.valueForTypedStringParameterV2(\n      scope,\n      parameterName,\n      ParameterValueType.STRING,\n      version,\n    );\n  }\n\n  /**\n   * Returns a token that will resolve (during deployment) to the string value of an SSM string parameter.\n   * @param scope Some scope within a stack\n   * @param parameterName The name of the SSM parameter.\n   * @param type The type of the SSM parameter.\n   * @param version The parameter version (recommended in order to ensure that the value won't change during deployment)\n   */\n  public static valueForTypedStringParameterV2(\n    scope: Construct,\n    parameterName: string,\n    type = ParameterValueType.STRING,\n    version?: number,\n  ): string {\n    const stack = AwsStack.of(scope);\n    const id = makeIdentityForImportedValue(parameterName);\n    const exists = stack.node.tryFindChild(id) as IStringParameter;\n\n    if (exists) {\n      return exists.stringValue;\n    }\n\n    return this.fromStringParameterAttributes(stack, id, {\n      parameterName,\n      version,\n      valueType: type,\n    }).stringValue;\n  }\n\n  /**\n   * Returns a token that will resolve (during deployment) to the string value of an SSM string parameter.\n   * @param scope Some scope within a stack\n   * @param parameterName The name of the SSM parameter.\n   * @param type The type of the SSM parameter.\n   * @param version The parameter version (recommended in order to ensure that the value won't change during deployment)\n   * @deprecated - use valueForTypedStringParameterV2 instead\n   */\n  public static valueForTypedStringParameter(\n    scope: Construct,\n    parameterName: string,\n    type = ParameterType.STRING,\n    version?: number,\n  ): string {\n    if (type === ParameterType.STRING_LIST) {\n      throw new Error(\n        \"valueForTypedStringParameter does not support STRING_LIST, \" +\n          \"use valueForTypedListParameter instead\",\n      );\n    }\n    const stack = AwsStack.of(scope);\n    const id = makeIdentityForImportedValue(parameterName);\n    const exists = stack.node.tryFindChild(id) as IStringParameter;\n\n    if (exists) {\n      return exists.stringValue;\n    }\n\n    return this.fromStringParameterAttributes(stack, id, {\n      parameterName,\n      version,\n      type,\n    }).stringValue;\n  }\n\n  /**\n   * Returns a token that will resolve (during deployment)\n   * @param scope Some scope within a stack\n   * @param parameterName The name of the SSM parameter\n   * @param version The parameter version (required for secure strings)\n   * @deprecated Use `SecretValue.ssmSecure()` instead, it will correctly type the imported value as a `SecretValue` and allow importing without version. `SecretValue` lives in the core `aws-cdk-lib` module.\n   */\n  public static valueForSecureStringParameter(\n    scope: Construct,\n    parameterName: string,\n    version: number,\n  ): string {\n    const stack = AwsStack.of(scope);\n    const id = makeIdentityForImportedValue(parameterName);\n    const exists = stack.node.tryFindChild(id) as IStringParameter;\n    if (exists) {\n      return exists.stringValue;\n    }\n\n    return this.fromSecureStringParameterAttributes(stack, id, {\n      parameterName,\n      version,\n    }).stringValue;\n  }\n\n  public readonly parameterArn: string;\n  public readonly parameterName: string;\n  public readonly parameterType: string;\n  public readonly stringValue: string;\n  public readonly resource: ssmParameter.SsmParameter;\n\n  constructor(scope: Construct, id: string, props: StringParameterProps) {\n    super(scope, id, props);\n    const parameterName =\n      props.parameterName ||\n      this.stack.uniqueResourceName(this, {\n        prefix: this.gridUUID,\n      });\n\n    if (props.stringValue && props.sensitiveStringValue) {\n      throw new Error(\n        \"Cannot specify both 'stringValue' and 'sensitiveStringValue'\",\n      );\n    }\n    const stringValue = props.stringValue ?? props.sensitiveStringValue;\n    const isSensitive = !!props.sensitiveStringValue;\n    if (!stringValue) {\n      throw new Error(\n        \"Either 'stringValue' or 'sensitiveStringValue' must be specified\",\n      );\n    }\n\n    if (props.allowedPattern) {\n      _assertValidValue(stringValue, props.allowedPattern);\n    }\n\n    validateParameterName(parameterName);\n\n    if (props.description && props.description?.length > 1024) {\n      throw new Error(\"Description cannot be longer than 1024 characters.\");\n    }\n\n    if (props.type && props.type === ParameterType.AWS_EC2_IMAGE_ID) {\n      throw new Error(\n        \"The type must either be ParameterType.STRING or ParameterType.STRING_LIST. Did you mean to set dataType: ParameterDataType.AWS_EC2_IMAGE instead?\",\n      );\n    }\n\n    this.resource = new ssmParameter.SsmParameter(this, \"Resource\", {\n      allowedPattern: props.allowedPattern,\n      description: props.description,\n      name: parameterName,\n      tier: props.tier,\n      type: props.type ?? ParameterType.STRING,\n      dataType: props.dataType,\n      insecureValue: props.stringValue,\n      value: props.sensitiveStringValue,\n    });\n\n    this.parameterName = this.resource.name;\n    this.parameterArn = arnForParameterName(this, this.parameterName, {\n      physicalName: parameterName,\n      simpleName: props.simpleName,\n    });\n\n    this.parameterType = this.resource.type;\n    this.stringValue = isSensitive\n      ? this.resource.value\n      : this.resource.insecureValue;\n  }\n}\n\n/**\n * Creates a new StringList SSM Parameter.\n * @resource AWS::SSM::Parameter\n */\nexport class StringListParameter\n  extends ParameterBase\n  implements IStringListParameter\n{\n  /**\n   * Imports an external parameter of type string list.\n   * Returns a token and should not be parsed.\n   */\n  public static fromStringListParameterName(\n    scope: Construct,\n    id: string,\n    stringListParameterName: string,\n  ): IStringListParameter {\n    // ref: dynamic ref\n    // https://github.com/aws/aws-cdk/blob/v2.143.0/packages/aws-cdk-lib/aws-ssm/lib/parameter.ts#L670\n    return StringListParameter.fromListParameterAttributes(scope, id, {\n      parameterName: stringListParameterName,\n    });\n  }\n\n  /**\n   * Imports an external string list parameter with name and optional version.\n   */\n  public static fromListParameterAttributes(\n    scope: Construct,\n    id: string,\n    attrs: ListParameterAttributes,\n  ): IStringListParameter {\n    if (!attrs.parameterName) {\n      throw new Error(\"parameterName cannot be an empty string\");\n    }\n\n    let name: string;\n    if (attrs.version) {\n      name = `${attrs.parameterName}:${Tokenization.stringifyNumber(attrs.version)}`;\n    } else {\n      name = attrs.parameterName;\n    }\n    const type = attrs.elementType ?? ParameterValueType.STRING;\n    const valueType = `List<${type}>`;\n\n    const resource = new dataAwsSsmParameter.DataAwsSsmParameter(\n      scope,\n      `${id}.Parameter`,\n      {\n        name,\n        withDecryption: attrs.withDecryption, // defaults to true\n      },\n    );\n\n    class Import extends ParameterBase {\n      public readonly parameterName = attrs.parameterName;\n      public readonly parameterArn = arnForParameterName(\n        this,\n        attrs.parameterName,\n        { simpleName: attrs.simpleName },\n      );\n      public readonly parameterType = valueType; // it doesn't really matter what this is since a CfnParameter can only be `String | StringList`\n      public readonly stringListValue = Fn.split(\",\", resource.insecureValue);\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * Returns a token that will resolve (during deployment) to the list value of an SSM StringList parameter.\n   * @param scope Some scope within a stack\n   * @param parameterName The name of the SSM parameter.\n   * @param type the type of the SSM list parameter\n   * @param version The parameter version (recommended in order to ensure that the value won't change during deployment)\n   */\n  public static valueForTypedListParameter(\n    scope: Construct,\n    parameterName: string,\n    type = ParameterValueType.STRING,\n    version?: number,\n  ): string[] {\n    const stack = AwsStack.of(scope);\n    const id = makeIdentityForImportedValue(parameterName);\n    const exists = stack.node.tryFindChild(id) as IStringListParameter;\n\n    if (exists) {\n      return exists.stringListValue;\n    }\n\n    return this.fromListParameterAttributes(stack, id, {\n      parameterName,\n      elementType: type,\n      version,\n    }).stringListValue;\n  }\n\n  public readonly parameterArn: string;\n  public readonly parameterName: string;\n  public readonly parameterType: string;\n  public readonly stringListValue: string[];\n  public readonly resource: ssmParameter.SsmParameter;\n\n  constructor(scope: Construct, id: string, props: StringListParameterProps) {\n    super(scope, id, props);\n    const parameterName =\n      props.parameterName ||\n      this.stack.uniqueResourceName(this, {\n        prefix: this.gridUUID,\n      });\n\n    if (props.stringListValue && props.sensitiveStringListValue) {\n      throw new Error(\n        \"Cannot specify both 'stringListValue' and 'sensitiveStringListValue'\",\n      );\n    }\n    const stringListValue =\n      props.stringListValue ?? props.sensitiveStringListValue;\n    const isSensitive = !!props.sensitiveStringListValue;\n    if (!stringListValue) {\n      throw new Error(\n        \"Either 'stringListValue' or 'sensitiveStringListValue' must be specified\",\n      );\n    }\n\n    if (\n      stringListValue.find(\n        (str) => !Token.isUnresolved(str) && str.indexOf(\",\") !== -1,\n      )\n    ) {\n      throw new Error(\n        \"Values of a StringList SSM Parameter cannot contain the ',' character. Use a string parameter instead.\",\n      );\n    }\n\n    if (props.allowedPattern && !Token.isUnresolved(stringListValue)) {\n      stringListValue.forEach((str) =>\n        _assertValidValue(str, props.allowedPattern!),\n      );\n    }\n\n    validateParameterName(parameterName);\n\n    if (props.description && props.description?.length > 1024) {\n      throw new Error(\"Description cannot be longer than 1024 characters.\");\n    }\n\n    this.resource = new ssmParameter.SsmParameter(this, \"Resource\", {\n      allowedPattern: props.allowedPattern,\n      description: props.description,\n      name: parameterName,\n      tier: props.tier,\n      type: ParameterType.STRING_LIST,\n      insecureValue: props.stringListValue\n        ? Fn.join(\",\", props.stringListValue)\n        : undefined,\n      value: props.sensitiveStringListValue\n        ? Fn.join(\",\", props.sensitiveStringListValue)\n        : undefined,\n    });\n    this.parameterName = this.resource.name;\n    this.parameterArn = arnForParameterName(this, this.parameterName, {\n      physicalName: parameterName,\n      simpleName: props.simpleName,\n    });\n\n    this.parameterType = this.resource.type;\n    this.stringListValue = isSensitive\n      ? Fn.split(\",\", this.resource.value)\n      : Fn.split(\",\", this.resource.insecureValue);\n  }\n}\n\n/**\n * Validates whether a supplied value conforms to the allowedPattern, granted neither is an unresolved token.\n *\n * @param value          the value to be validated.\n * @param allowedPattern the regular expression to use for validation.\n *\n * @throws if the ``value`` does not conform to the ``allowedPattern`` and neither is an unresolved token (per\n *         ``cdk.unresolved``).\n */\nfunction _assertValidValue(value: string, allowedPattern: string): void {\n  if (Token.isUnresolved(value) || Token.isUnresolved(allowedPattern)) {\n    // Unable to perform validations against unresolved tokens\n    return;\n  }\n  if (!new RegExp(allowedPattern).test(value)) {\n    throw new Error(\n      `The supplied value (${value}) does not match the specified allowedPattern (${allowedPattern})`,\n    );\n  }\n}\n\nfunction makeIdentityForImportedValue(parameterName: string) {\n  return `SsmParameterValue:${parameterName}:C96584B6-F00A-464E-AD19-53AFF4B05118`;\n}\n\nfunction validateParameterName(parameterName: string) {\n  if (Token.isUnresolved(parameterName)) {\n    return;\n  }\n  if (parameterName.length > 2048) {\n    throw new Error(\"name cannot be longer than 2048 characters.\");\n  }\n  if (!parameterName.match(/^[\\/\\w.-]+$/)) {\n    throw new Error(\n      `name must only contain letters, numbers, and the following 4 symbols .-_/; got ${parameterName}`,\n    );\n  }\n}\n"]}