terraconstructs 0.0.8

package/lib/aws/arn.d.ts

@@ -0,0 +1,187 @@
+import { IAwsStack } from "./aws-stack";
+/**
+ * An enum representing the various ARN formats that different services use.
+ */
+export declare enum ArnFormat {
+    /**
+     * This represents a format where there is no 'resourceName' part.
+     * This format is used for S3 resources,
+     * like 'arn:aws:s3:::bucket'.
+     * Everything after the last colon is considered the 'resource',
+     * even if it contains slashes,
+     * like in 'arn:aws:s3:::bucket/object.zip'.
+     */
+    NO_RESOURCE_NAME = "arn:aws:service:region:account:resource",
+    /**
+     * This represents a format where the 'resource' and 'resourceName'
+     * parts are separated with a colon.
+     * Like in: 'arn:aws:service:region:account:resource:resourceName'.
+     * Everything after the last colon is considered the 'resourceName',
+     * even if it contains slashes,
+     * like in 'arn:aws:apigateway:region:account:resource:/test/mydemoresource/*'.
+     */
+    COLON_RESOURCE_NAME = "arn:aws:service:region:account:resource:resourceName",
+    /**
+     * This represents a format where the 'resource' and 'resourceName'
+     * parts are separated with a slash.
+     * Like in: 'arn:aws:service:region:account:resource/resourceName'.
+     * Everything after the separating slash is considered the 'resourceName',
+     * even if it contains colons,
+     * like in 'arn:aws:cognito-sync:region:account:identitypool/us-east-1:1a1a1a1a-ffff-1111-9999-12345678:bla'.
+     */
+    SLASH_RESOURCE_NAME = "arn:aws:service:region:account:resource/resourceName",
+    /**
+     * This represents a format where the 'resource' and 'resourceName'
+     * parts are seperated with a slash,
+     * but there is also an additional slash after the colon separating 'account' from 'resource'.
+     * Like in: 'arn:aws:service:region:account:/resource/resourceName'.
+     * Note that the leading slash is _not_ included in the parsed 'resource' part.
+     */
+    SLASH_RESOURCE_SLASH_RESOURCE_NAME = "arn:aws:service:region:account:/resource/resourceName"
+}
+export interface ArnComponents {
+    /**
+     * The partition that the resource is in. For standard AWS regions, the
+     * partition is aws. If you have resources in other partitions, the
+     * partition is aws-partitionname. For example, the partition for resources
+     * in the China (Beijing) region is aws-cn.
+     *
+     * @default The AWS partition the stack is deployed to.
+     */
+    readonly partition?: string;
+    /**
+     * The service namespace that identifies the AWS product (for example,
+     * 's3', 'iam', 'codepipline').
+     */
+    readonly service: string;
+    /**
+     * The region the resource resides in. Note that the ARNs for some resources
+     * do not require a region, so this component might be omitted.
+     *
+     * @default The region the stack is deployed to.
+     */
+    readonly region?: string;
+    /**
+     * The ID of the AWS account that owns the resource, without the hyphens.
+     * For example, 123456789012. Note that the ARNs for some resources don't
+     * require an account number, so this component might be omitted.
+     *
+     * @default The account the stack is deployed to.
+     */
+    readonly account?: string;
+    /**
+     * Resource type (e.g. "table", "autoScalingGroup", "certificate").
+     * For some resource types, e.g. S3 buckets, this field defines the bucket name.
+     */
+    readonly resource: string;
+    /**
+     * Separator between resource type and the resource.
+     *
+     * Can be either '/', ':' or an empty string. Will only be used if resourceName is defined.
+     * @default '/'
+     *
+     * @deprecated use arnFormat instead
+     */
+    readonly sep?: string;
+    /**
+     * Resource name or path within the resource (i.e. S3 bucket object key) or
+     * a wildcard such as ``"*"``. This is service-dependent.
+     */
+    readonly resourceName?: string;
+    /**
+     * The specific ARN format to use for this ARN value.
+     *
+     * @default - uses value of `sep` as the separator for formatting,
+     *   `ArnFormat.SLASH_RESOURCE_NAME` if that property was also notd
+     */
+    readonly arnFormat?: ArnFormat;
+}
+export declare class Arn {
+    /**
+     * Creates an ARN from components.
+     *
+     * If `partition`, `region` or `account` are not specified, the stack's
+     * partition, region and account will be used.
+     *
+     * If any component is the empty string, an empty string will be inserted
+     * into the generated ARN at the location that component corresponds to.
+     *
+     * The ARN will be formatted as follows:
+     *
+     *   arn:{partition}:{service}:{region}:{account}:{resource}{sep}{resource-name}
+     *
+     * The required ARN pieces that are omitted will be taken from the stack that
+     * the 'scope' is attached to. If all ARN pieces are supplied, the supplied scope
+     * can be 'undefined'.
+     */
+    static format(components: ArnComponents, stack?: IAwsStack): string;
+    /**
+     * Given an ARN, parses it and returns components.
+     *
+     * IF THE ARN IS A CONCRETE STRING...
+     *
+     * ...it will be parsed and validated. The separator (`sep`) will be set to '/'
+     * if the 6th component includes a '/', in which case, `resource` will be set
+     * to the value before the '/' and `resourceName` will be the rest. In case
+     * there is no '/', `resource` will be set to the 6th components and
+     * `resourceName` will be set to the rest of the string.
+     *
+     * IF THE ARN IS A TOKEN...
+     *
+     * ...it cannot be validated, since we don't have the actual value yet at the
+     * time of this function call. You will have to supply `sepIfToken` and
+     * whether or not ARNs of the expected format usually have resource names
+     * in order to parse it properly. The resulting `ArnComponents` object will
+     * contain tokens for the subexpressions of the ARN, not string literals.
+     *
+     * If the resource name could possibly contain the separator char, the actual
+     * resource name cannot be properly parsed. This only occurs if the separator
+     * char is '/', and happens for example for S3 object ARNs, IAM Role ARNs,
+     * IAM OIDC Provider ARNs, etc. To properly extract the resource name from a
+     * Tokenized ARN, you must know the resource type and call
+     * `Arn.extractResourceName`.
+     *
+     * @param arn The ARN to parse
+     * @param sepIfToken The separator used to separate resource from resourceName
+     * @param hasName Whether there is a name component in the ARN at all. For
+     * example, SNS Topics ARNs have the 'resource' component contain the topic
+     * name, and no 'resourceName' component.
+     *
+     * @returns an ArnComponents object which allows access to the various
+     * components of the ARN.
+     *
+     * @returns an ArnComponents object which allows access to the various
+     *      components of the ARN.
+     *
+     * @deprecated use split instead
+     */
+    static parse(arn: string, sepIfToken?: string, hasName?: boolean): ArnComponents;
+    /**
+     * Splits the provided ARN into its components.
+     * Works both if 'arn' is a string like 'arn:aws:s3:::bucket',
+     * and a Token representing a dynamic CloudFormation expression
+     * (in which case the returned components will also be dynamic CloudFormation expressions,
+     * encoded as Tokens).
+     *
+     * @param arn the ARN to split into its components
+     * @param arnFormat the expected format of 'arn' - depends on what format the service 'arn' represents uses
+     */
+    static split(arn: string, arnFormat: ArnFormat): ArnComponents;
+    /**
+     * Extract the full resource name from an ARN
+     *
+     * Necessary for resource names (paths) that may contain the separator, like
+     * `arn:aws:iam::111111111111:role/path/to/role/name`.
+     *
+     * Only works if we statically know the expected `resourceType` beforehand, since we're going
+     * to use that to split the string on ':<resourceType>/' (and take the right-hand side).
+     *
+     * We can't extract the 'resourceType' from the ARN at hand, because CloudFormation Expressions
+     * only allow literals in the 'separator' argument to `{ Fn::Split }`, and so it can't be
+     * `{ Fn::Select: [5, { Fn::Split: [':', ARN] }}`.
+     *
+     * Only necessary for ARN formats for which the type-name separator is `/`.
+     */
+    static extractResourceName(arn: string, resourceType: string): string;
+    private constructor();
+}

package/lib/aws/arn.js

@@ -0,0 +1,383 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Arn = exports.ArnFormat = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// ref: https://github.com/aws/aws-cdk/blob/v2.150.0/packages/aws-cdk-lib/core/lib/arn.ts
+const cdktf = require("cdktf");
+const util_1 = require("./util");
+/**
+ * An enum representing the various ARN formats that different services use.
+ */
+var ArnFormat;
+(function (ArnFormat) {
+    /**
+     * This represents a format where there is no 'resourceName' part.
+     * This format is used for S3 resources,
+     * like 'arn:aws:s3:::bucket'.
+     * Everything after the last colon is considered the 'resource',
+     * even if it contains slashes,
+     * like in 'arn:aws:s3:::bucket/object.zip'.
+     */
+    ArnFormat["NO_RESOURCE_NAME"] = "arn:aws:service:region:account:resource";
+    /**
+     * This represents a format where the 'resource' and 'resourceName'
+     * parts are separated with a colon.
+     * Like in: 'arn:aws:service:region:account:resource:resourceName'.
+     * Everything after the last colon is considered the 'resourceName',
+     * even if it contains slashes,
+     * like in 'arn:aws:apigateway:region:account:resource:/test/mydemoresource/*'.
+     */
+    ArnFormat["COLON_RESOURCE_NAME"] = "arn:aws:service:region:account:resource:resourceName";
+    /**
+     * This represents a format where the 'resource' and 'resourceName'
+     * parts are separated with a slash.
+     * Like in: 'arn:aws:service:region:account:resource/resourceName'.
+     * Everything after the separating slash is considered the 'resourceName',
+     * even if it contains colons,
+     * like in 'arn:aws:cognito-sync:region:account:identitypool/us-east-1:1a1a1a1a-ffff-1111-9999-12345678:bla'.
+     */
+    ArnFormat["SLASH_RESOURCE_NAME"] = "arn:aws:service:region:account:resource/resourceName";
+    /**
+     * This represents a format where the 'resource' and 'resourceName'
+     * parts are seperated with a slash,
+     * but there is also an additional slash after the colon separating 'account' from 'resource'.
+     * Like in: 'arn:aws:service:region:account:/resource/resourceName'.
+     * Note that the leading slash is _not_ included in the parsed 'resource' part.
+     */
+    ArnFormat["SLASH_RESOURCE_SLASH_RESOURCE_NAME"] = "arn:aws:service:region:account:/resource/resourceName";
+})(ArnFormat || (exports.ArnFormat = ArnFormat = {}));
+class Arn {
+    /**
+     * Creates an ARN from components.
+     *
+     * If `partition`, `region` or `account` are not specified, the stack's
+     * partition, region and account will be used.
+     *
+     * If any component is the empty string, an empty string will be inserted
+     * into the generated ARN at the location that component corresponds to.
+     *
+     * The ARN will be formatted as follows:
+     *
+     *   arn:{partition}:{service}:{region}:{account}:{resource}{sep}{resource-name}
+     *
+     * The required ARN pieces that are omitted will be taken from the stack that
+     * the 'scope' is attached to. If all ARN pieces are supplied, the supplied scope
+     * can be 'undefined'.
+     */
+    static format(components, stack) {
+        const partition = components.partition ?? stack?.partition;
+        const region = components.region ?? stack?.region;
+        const account = components.account ?? stack?.account;
+        // Catch both 'null' and 'undefined'
+        if (partition == null || region == null || account == null) {
+            throw new Error(`Arn.format: partition (${partition}), region (${region}), and account (${account}) must all be passed if stack is not passed.`);
+        }
+        const sep = components.sep ??
+            (components.arnFormat === ArnFormat.COLON_RESOURCE_NAME ? ":" : "/");
+        const values = [
+            "arn",
+            ":",
+            partition,
+            ":",
+            components.service,
+            ":",
+            region,
+            ":",
+            account,
+            ":",
+            ...(components.arnFormat === ArnFormat.SLASH_RESOURCE_SLASH_RESOURCE_NAME
+                ? ["/"]
+                : []),
+            components.resource,
+        ];
+        if (sep !== "/" && sep !== ":" && sep !== "") {
+            throw new Error('resourcePathSep may only be ":", "/" or an empty string');
+        }
+        if (components.resourceName != null) {
+            values.push(sep);
+            values.push(components.resourceName);
+        }
+        return values.join("");
+    }
+    /**
+     * Given an ARN, parses it and returns components.
+     *
+     * IF THE ARN IS A CONCRETE STRING...
+     *
+     * ...it will be parsed and validated. The separator (`sep`) will be set to '/'
+     * if the 6th component includes a '/', in which case, `resource` will be set
+     * to the value before the '/' and `resourceName` will be the rest. In case
+     * there is no '/', `resource` will be set to the 6th components and
+     * `resourceName` will be set to the rest of the string.
+     *
+     * IF THE ARN IS A TOKEN...
+     *
+     * ...it cannot be validated, since we don't have the actual value yet at the
+     * time of this function call. You will have to supply `sepIfToken` and
+     * whether or not ARNs of the expected format usually have resource names
+     * in order to parse it properly. The resulting `ArnComponents` object will
+     * contain tokens for the subexpressions of the ARN, not string literals.
+     *
+     * If the resource name could possibly contain the separator char, the actual
+     * resource name cannot be properly parsed. This only occurs if the separator
+     * char is '/', and happens for example for S3 object ARNs, IAM Role ARNs,
+     * IAM OIDC Provider ARNs, etc. To properly extract the resource name from a
+     * Tokenized ARN, you must know the resource type and call
+     * `Arn.extractResourceName`.
+     *
+     * @param arn The ARN to parse
+     * @param sepIfToken The separator used to separate resource from resourceName
+     * @param hasName Whether there is a name component in the ARN at all. For
+     * example, SNS Topics ARNs have the 'resource' component contain the topic
+     * name, and no 'resourceName' component.
+     *
+     * @returns an ArnComponents object which allows access to the various
+     * components of the ARN.
+     *
+     * @returns an ArnComponents object which allows access to the various
+     *      components of the ARN.
+     *
+     * @deprecated use split instead
+     */
+    static parse(arn, sepIfToken = "/", hasName = true) {
+        let arnFormat;
+        if (!hasName) {
+            arnFormat = ArnFormat.NO_RESOURCE_NAME;
+        }
+        else {
+            arnFormat =
+                sepIfToken === "/"
+                    ? ArnFormat.SLASH_RESOURCE_NAME
+                    : ArnFormat.COLON_RESOURCE_NAME;
+        }
+        return this.split(arn, arnFormat);
+    }
+    /**
+     * Splits the provided ARN into its components.
+     * Works both if 'arn' is a string like 'arn:aws:s3:::bucket',
+     * and a Token representing a dynamic CloudFormation expression
+     * (in which case the returned components will also be dynamic CloudFormation expressions,
+     * encoded as Tokens).
+     *
+     * @param arn the ARN to split into its components
+     * @param arnFormat the expected format of 'arn' - depends on what format the service 'arn' represents uses
+     */
+    static split(arn, arnFormat) {
+        const components = parseArnShape(arn);
+        if (components === "token") {
+            return parseTokenArn(arn, arnFormat);
+        }
+        const [, partition, service, region, account, resourceTypeOrName, ...rest] = components;
+        let resource;
+        let resourceName;
+        let sep;
+        let resourcePartStartIndex = 0;
+        let detectedArnFormat;
+        let slashIndex = resourceTypeOrName.indexOf("/");
+        if (slashIndex === 0) {
+            // new-style ARNs are of the form 'arn:aws:s4:us-west-1:12345:/resource-type/resource-name'
+            slashIndex = resourceTypeOrName.indexOf("/", 1);
+            resourcePartStartIndex = 1;
+            detectedArnFormat = ArnFormat.SLASH_RESOURCE_SLASH_RESOURCE_NAME;
+        }
+        if (slashIndex !== -1) {
+            // the slash is only a separator if ArnFormat is not NO_RESOURCE_NAME
+            if (arnFormat === ArnFormat.NO_RESOURCE_NAME) {
+                sep = undefined;
+                slashIndex = -1;
+                detectedArnFormat = ArnFormat.NO_RESOURCE_NAME;
+            }
+            else {
+                sep = "/";
+                detectedArnFormat =
+                    resourcePartStartIndex === 0
+                        ? ArnFormat.SLASH_RESOURCE_NAME
+                        : // need to repeat this here, as otherwise the compiler thinks 'detectedArnFormat' is not initialized in all paths
+                            ArnFormat.SLASH_RESOURCE_SLASH_RESOURCE_NAME;
+            }
+        }
+        else if (rest.length > 0) {
+            sep = ":";
+            slashIndex = -1;
+            detectedArnFormat = ArnFormat.COLON_RESOURCE_NAME;
+        }
+        else {
+            sep = undefined;
+            detectedArnFormat = ArnFormat.NO_RESOURCE_NAME;
+        }
+        if (slashIndex !== -1) {
+            resource = resourceTypeOrName.substring(resourcePartStartIndex, slashIndex);
+            resourceName = resourceTypeOrName.substring(slashIndex + 1);
+        }
+        else {
+            resource = resourceTypeOrName;
+        }
+        if (rest.length > 0) {
+            if (!resourceName) {
+                resourceName = "";
+            }
+            else {
+                resourceName += ":";
+            }
+            resourceName += rest.join(":");
+        }
+        // "|| undefined" will cause empty strings to be treated as "undefined".
+        // Optional ARN attributes (e.g. region, account) should return as empty string
+        // if they are provided as such.
+        return (0, util_1.filterUndefined)({
+            service: service || undefined,
+            resource: resource || undefined,
+            partition: partition || undefined,
+            region,
+            account,
+            resourceName,
+            sep,
+            arnFormat: detectedArnFormat,
+        });
+    }
+    /**
+     * Extract the full resource name from an ARN
+     *
+     * Necessary for resource names (paths) that may contain the separator, like
+     * `arn:aws:iam::111111111111:role/path/to/role/name`.
+     *
+     * Only works if we statically know the expected `resourceType` beforehand, since we're going
+     * to use that to split the string on ':<resourceType>/' (and take the right-hand side).
+     *
+     * We can't extract the 'resourceType' from the ARN at hand, because CloudFormation Expressions
+     * only allow literals in the 'separator' argument to `{ Fn::Split }`, and so it can't be
+     * `{ Fn::Select: [5, { Fn::Split: [':', ARN] }}`.
+     *
+     * Only necessary for ARN formats for which the type-name separator is `/`.
+     */
+    static extractResourceName(arn, resourceType) {
+        const components = parseArnShape(arn);
+        if (components === "token") {
+            return cdktf.Fn.element(cdktf.Fn.split(`:${resourceType}/`, arn), 1);
+        }
+        // Apparently we could just parse this right away. Validate that we got the right
+        // resource type (to notify authors of incorrect assumptions right away).
+        const parsed = Arn.split(arn, ArnFormat.SLASH_RESOURCE_NAME);
+        if (!cdktf.Token.isUnresolved(parsed.resource) &&
+            parsed.resource !== resourceType) {
+            throw new Error(`Expected resource type '${resourceType}' in ARN, got '${parsed.resource}' in '${arn}'`);
+        }
+        if (!parsed.resourceName) {
+            throw new Error(`Expected resource name in ARN, didn't find one: '${arn}'`);
+        }
+        return parsed.resourceName;
+    }
+    constructor() { }
+}
+exports.Arn = Arn;
+_a = JSII_RTTI_SYMBOL_1;
+Arn[_a] = { fqn: "terraconstructs.aws.Arn", version: "0.0.8" };
+/**
+ * Given a Token evaluating to ARN, parses it and returns components.
+ *
+ * The ARN cannot be validated, since we don't have the actual value yet
+ * at the time of this function call. You will have to know the separator
+ * and the type of ARN.
+ *
+ * The resulting `ArnComponents` object will contain tokens for the
+ * subexpressions of the ARN, not string literals.
+ *
+ * WARNING: this function cannot properly parse the complete final
+ * 'resourceName' part if it contains colons,
+ * like 'arn:aws:cognito-sync:region:account:identitypool/us-east-1:1a1a1a1a-ffff-1111-9999-12345678:bla'.
+ *
+ * @param arnToken The input token that contains an ARN
+ * @param arnFormat the expected format of 'arn' - depends on what format the service the ARN represents uses
+ */
+function parseTokenArn(arnToken, arnFormat) {
+    // ARN looks like:
+    // arn:partition:service:region:account:resource
+    // arn:partition:service:region:account:resource:resourceName
+    // arn:partition:service:region:account:resource/resourceName
+    // arn:partition:service:region:account:/resource/resourceName
+    const components = cdktf.Fn.split(":", arnToken);
+    const partition = cdktf.Fn.element(components, 1).toString();
+    const service = cdktf.Fn.element(components, 2).toString();
+    const region = cdktf.Fn.element(components, 3).toString();
+    const account = cdktf.Fn.element(components, 4).toString();
+    let resource;
+    let resourceName;
+    let sep;
+    if (arnFormat === ArnFormat.NO_RESOURCE_NAME ||
+        arnFormat === ArnFormat.COLON_RESOURCE_NAME) {
+        // we know that the 'resource' part will always be the 6th segment in this case
+        resource = cdktf.Fn.element(components, 5);
+        if (arnFormat === ArnFormat.COLON_RESOURCE_NAME) {
+            resourceName = cdktf.Fn.element(components, 6);
+            sep = ":";
+        }
+        else {
+            resourceName = undefined;
+            sep = undefined;
+        }
+    }
+    else {
+        // we know that the 'resource' and 'resourceName' parts are separated by slash here,
+        // so we split the 6th segment from the colon-separated ones with a slash
+        const lastComponents = cdktf.Fn.split("/", cdktf.Fn.element(components, 5));
+        if (arnFormat === ArnFormat.SLASH_RESOURCE_NAME) {
+            resource = cdktf.Fn.element(lastComponents, 0);
+            resourceName = cdktf.Fn.element(lastComponents, 1);
+        }
+        else {
+            // arnFormat is ArnFormat.SLASH_RESOURCE_SLASH_RESOURCE_NAME,
+            // which means there's an extra slash there at the beginning that we need to skip
+            resource = cdktf.Fn.element(lastComponents, 1);
+            resourceName = cdktf.Fn.element(lastComponents, 2);
+        }
+        sep = "/";
+    }
+    return {
+        partition,
+        service,
+        region,
+        account,
+        resource,
+        resourceName,
+        sep,
+        arnFormat,
+    };
+}
+/**
+ * Validate that a string is either unparseable or looks mostly like an ARN
+ */
+function parseArnShape(arn) {
+    // assume anything that starts with 'arn:' is an ARN,
+    // so we can report better errors
+    const looksLikeArn = arn.startsWith("arn:");
+    if (!looksLikeArn) {
+        if (cdktf.Token.isUnresolved(arn)) {
+            return "token";
+        }
+        else {
+            throw new Error(`ARNs must start with "arn:" and have at least 6 components: ${arn}`);
+        }
+    }
+    // If the ARN merely contains Tokens, but otherwise *looks* mostly like an ARN,
+    // it's a string of the form 'arn:${partition}:service:${region}:${account}:resource/xyz'.
+    // Parse fields out to the best of our ability.
+    // Tokens won't contain ":", so this won't break them.
+    const components = arn.split(":");
+    const partition = components.length > 1 ? components[1] : undefined;
+    if (!partition) {
+        throw new Error("The `partition` component (2nd component) of an ARN is required: " + arn);
+    }
+    const service = components.length > 2 ? components[2] : undefined;
+    if (!service) {
+        throw new Error("The `service` component (3rd component) of an ARN is required: " + arn);
+    }
+    const resource = components.length > 5 ? components[5] : undefined;
+    if (!resource) {
+        throw new Error("The `resource` component (6th component) of an ARN is required: " + arn);
+    }
+    // Region can be missing in global ARNs (such as used by IAM)
+    // Account can be missing in some ARN types (such as used for S3 buckets)
+    return components;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"arn.js","sourceRoot":"","sources":["../../src/aws/arn.ts"],"names":[],"mappings":"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","sourcesContent":["// ref: https://github.com/aws/aws-cdk/blob/v2.150.0/packages/aws-cdk-lib/core/lib/arn.ts\nimport * as cdktf from \"cdktf\";\nimport { IAwsStack } from \"./aws-stack\";\nimport { filterUndefined } from \"./util\";\n/**\n * An enum representing the various ARN formats that different services use.\n */\nexport enum ArnFormat {\n  /**\n   * This represents a format where there is no 'resourceName' part.\n   * This format is used for S3 resources,\n   * like 'arn:aws:s3:::bucket'.\n   * Everything after the last colon is considered the 'resource',\n   * even if it contains slashes,\n   * like in 'arn:aws:s3:::bucket/object.zip'.\n   */\n  NO_RESOURCE_NAME = \"arn:aws:service:region:account:resource\",\n\n  /**\n   * This represents a format where the 'resource' and 'resourceName'\n   * parts are separated with a colon.\n   * Like in: 'arn:aws:service:region:account:resource:resourceName'.\n   * Everything after the last colon is considered the 'resourceName',\n   * even if it contains slashes,\n   * like in 'arn:aws:apigateway:region:account:resource:/test/mydemoresource/*'.\n   */\n  COLON_RESOURCE_NAME = \"arn:aws:service:region:account:resource:resourceName\",\n\n  /**\n   * This represents a format where the 'resource' and 'resourceName'\n   * parts are separated with a slash.\n   * Like in: 'arn:aws:service:region:account:resource/resourceName'.\n   * Everything after the separating slash is considered the 'resourceName',\n   * even if it contains colons,\n   * like in 'arn:aws:cognito-sync:region:account:identitypool/us-east-1:1a1a1a1a-ffff-1111-9999-12345678:bla'.\n   */\n  SLASH_RESOURCE_NAME = \"arn:aws:service:region:account:resource/resourceName\",\n\n  /**\n   * This represents a format where the 'resource' and 'resourceName'\n   * parts are seperated with a slash,\n   * but there is also an additional slash after the colon separating 'account' from 'resource'.\n   * Like in: 'arn:aws:service:region:account:/resource/resourceName'.\n   * Note that the leading slash is _not_ included in the parsed 'resource' part.\n   */\n  SLASH_RESOURCE_SLASH_RESOURCE_NAME = \"arn:aws:service:region:account:/resource/resourceName\",\n}\n\nexport interface ArnComponents {\n  /**\n   * The partition that the resource is in. For standard AWS regions, the\n   * partition is aws. If you have resources in other partitions, the\n   * partition is aws-partitionname. For example, the partition for resources\n   * in the China (Beijing) region is aws-cn.\n   *\n   * @default The AWS partition the stack is deployed to.\n   */\n  readonly partition?: string;\n\n  /**\n   * The service namespace that identifies the AWS product (for example,\n   * 's3', 'iam', 'codepipline').\n   */\n  readonly service: string;\n\n  /**\n   * The region the resource resides in. Note that the ARNs for some resources\n   * do not require a region, so this component might be omitted.\n   *\n   * @default The region the stack is deployed to.\n   */\n  readonly region?: string;\n\n  /**\n   * The ID of the AWS account that owns the resource, without the hyphens.\n   * For example, 123456789012. Note that the ARNs for some resources don't\n   * require an account number, so this component might be omitted.\n   *\n   * @default The account the stack is deployed to.\n   */\n  readonly account?: string;\n\n  /**\n   * Resource type (e.g. \"table\", \"autoScalingGroup\", \"certificate\").\n   * For some resource types, e.g. S3 buckets, this field defines the bucket name.\n   */\n  readonly resource: string;\n\n  /**\n   * Separator between resource type and the resource.\n   *\n   * Can be either '/', ':' or an empty string. Will only be used if resourceName is defined.\n   * @default '/'\n   *\n   * @deprecated use arnFormat instead\n   */\n  readonly sep?: string;\n\n  /**\n   * Resource name or path within the resource (i.e. S3 bucket object key) or\n   * a wildcard such as ``\"*\"``. This is service-dependent.\n   */\n  readonly resourceName?: string;\n\n  /**\n   * The specific ARN format to use for this ARN value.\n   *\n   * @default - uses value of `sep` as the separator for formatting,\n   *   `ArnFormat.SLASH_RESOURCE_NAME` if that property was also notd\n   */\n  readonly arnFormat?: ArnFormat;\n}\n\nexport class Arn {\n  /**\n   * Creates an ARN from components.\n   *\n   * If `partition`, `region` or `account` are not specified, the stack's\n   * partition, region and account will be used.\n   *\n   * If any component is the empty string, an empty string will be inserted\n   * into the generated ARN at the location that component corresponds to.\n   *\n   * The ARN will be formatted as follows:\n   *\n   *   arn:{partition}:{service}:{region}:{account}:{resource}{sep}{resource-name}\n   *\n   * The required ARN pieces that are omitted will be taken from the stack that\n   * the 'scope' is attached to. If all ARN pieces are supplied, the supplied scope\n   * can be 'undefined'.\n   */\n  public static format(components: ArnComponents, stack?: IAwsStack): string {\n    const partition = components.partition ?? stack?.partition;\n    const region = components.region ?? stack?.region;\n    const account = components.account ?? stack?.account;\n\n    // Catch both 'null' and 'undefined'\n    if (partition == null || region == null || account == null) {\n      throw new Error(\n        `Arn.format: partition (${partition}), region (${region}), and account (${account}) must all be passed if stack is not passed.`,\n      );\n    }\n\n    const sep =\n      components.sep ??\n      (components.arnFormat === ArnFormat.COLON_RESOURCE_NAME ? \":\" : \"/\");\n\n    const values = [\n      \"arn\",\n      \":\",\n      partition,\n      \":\",\n      components.service,\n      \":\",\n      region,\n      \":\",\n      account,\n      \":\",\n      ...(components.arnFormat === ArnFormat.SLASH_RESOURCE_SLASH_RESOURCE_NAME\n        ? [\"/\"]\n        : []),\n      components.resource,\n    ];\n\n    if (sep !== \"/\" && sep !== \":\" && sep !== \"\") {\n      throw new Error(\n        'resourcePathSep may only be \":\", \"/\" or an empty string',\n      );\n    }\n\n    if (components.resourceName != null) {\n      values.push(sep);\n      values.push(components.resourceName);\n    }\n\n    return values.join(\"\");\n  }\n\n  /**\n   * Given an ARN, parses it and returns components.\n   *\n   * IF THE ARN IS A CONCRETE STRING...\n   *\n   * ...it will be parsed and validated. The separator (`sep`) will be set to '/'\n   * if the 6th component includes a '/', in which case, `resource` will be set\n   * to the value before the '/' and `resourceName` will be the rest. In case\n   * there is no '/', `resource` will be set to the 6th components and\n   * `resourceName` will be set to the rest of the string.\n   *\n   * IF THE ARN IS A TOKEN...\n   *\n   * ...it cannot be validated, since we don't have the actual value yet at the\n   * time of this function call. You will have to supply `sepIfToken` and\n   * whether or not ARNs of the expected format usually have resource names\n   * in order to parse it properly. The resulting `ArnComponents` object will\n   * contain tokens for the subexpressions of the ARN, not string literals.\n   *\n   * If the resource name could possibly contain the separator char, the actual\n   * resource name cannot be properly parsed. This only occurs if the separator\n   * char is '/', and happens for example for S3 object ARNs, IAM Role ARNs,\n   * IAM OIDC Provider ARNs, etc. To properly extract the resource name from a\n   * Tokenized ARN, you must know the resource type and call\n   * `Arn.extractResourceName`.\n   *\n   * @param arn The ARN to parse\n   * @param sepIfToken The separator used to separate resource from resourceName\n   * @param hasName Whether there is a name component in the ARN at all. For\n   * example, SNS Topics ARNs have the 'resource' component contain the topic\n   * name, and no 'resourceName' component.\n   *\n   * @returns an ArnComponents object which allows access to the various\n   * components of the ARN.\n   *\n   * @returns an ArnComponents object which allows access to the various\n   *      components of the ARN.\n   *\n   * @deprecated use split instead\n   */\n  public static parse(\n    arn: string,\n    sepIfToken: string = \"/\",\n    hasName: boolean = true,\n  ): ArnComponents {\n    let arnFormat: ArnFormat;\n    if (!hasName) {\n      arnFormat = ArnFormat.NO_RESOURCE_NAME;\n    } else {\n      arnFormat =\n        sepIfToken === \"/\"\n          ? ArnFormat.SLASH_RESOURCE_NAME\n          : ArnFormat.COLON_RESOURCE_NAME;\n    }\n    return this.split(arn, arnFormat);\n  }\n\n  /**\n   * Splits the provided ARN into its components.\n   * Works both if 'arn' is a string like 'arn:aws:s3:::bucket',\n   * and a Token representing a dynamic CloudFormation expression\n   * (in which case the returned components will also be dynamic CloudFormation expressions,\n   * encoded as Tokens).\n   *\n   * @param arn the ARN to split into its components\n   * @param arnFormat the expected format of 'arn' - depends on what format the service 'arn' represents uses\n   */\n  public static split(arn: string, arnFormat: ArnFormat): ArnComponents {\n    const components = parseArnShape(arn);\n    if (components === \"token\") {\n      return parseTokenArn(arn, arnFormat);\n    }\n\n    const [, partition, service, region, account, resourceTypeOrName, ...rest] =\n      components;\n\n    let resource: string;\n    let resourceName: string | undefined;\n    let sep: string | undefined;\n    let resourcePartStartIndex = 0;\n    let detectedArnFormat: ArnFormat;\n\n    let slashIndex = resourceTypeOrName.indexOf(\"/\");\n    if (slashIndex === 0) {\n      // new-style ARNs are of the form 'arn:aws:s4:us-west-1:12345:/resource-type/resource-name'\n      slashIndex = resourceTypeOrName.indexOf(\"/\", 1);\n      resourcePartStartIndex = 1;\n      detectedArnFormat = ArnFormat.SLASH_RESOURCE_SLASH_RESOURCE_NAME;\n    }\n    if (slashIndex !== -1) {\n      // the slash is only a separator if ArnFormat is not NO_RESOURCE_NAME\n      if (arnFormat === ArnFormat.NO_RESOURCE_NAME) {\n        sep = undefined;\n        slashIndex = -1;\n        detectedArnFormat = ArnFormat.NO_RESOURCE_NAME;\n      } else {\n        sep = \"/\";\n        detectedArnFormat =\n          resourcePartStartIndex === 0\n            ? ArnFormat.SLASH_RESOURCE_NAME\n            : // need to repeat this here, as otherwise the compiler thinks 'detectedArnFormat' is not initialized in all paths\n              ArnFormat.SLASH_RESOURCE_SLASH_RESOURCE_NAME;\n      }\n    } else if (rest.length > 0) {\n      sep = \":\";\n      slashIndex = -1;\n      detectedArnFormat = ArnFormat.COLON_RESOURCE_NAME;\n    } else {\n      sep = undefined;\n      detectedArnFormat = ArnFormat.NO_RESOURCE_NAME;\n    }\n\n    if (slashIndex !== -1) {\n      resource = resourceTypeOrName.substring(\n        resourcePartStartIndex,\n        slashIndex,\n      );\n      resourceName = resourceTypeOrName.substring(slashIndex + 1);\n    } else {\n      resource = resourceTypeOrName;\n    }\n\n    if (rest.length > 0) {\n      if (!resourceName) {\n        resourceName = \"\";\n      } else {\n        resourceName += \":\";\n      }\n\n      resourceName += rest.join(\":\");\n    }\n\n    // \"|| undefined\" will cause empty strings to be treated as \"undefined\".\n    // Optional ARN attributes (e.g. region, account) should return as empty string\n    // if they are provided as such.\n    return filterUndefined({\n      service: service || undefined,\n      resource: resource || undefined,\n      partition: partition || undefined,\n      region,\n      account,\n      resourceName,\n      sep,\n      arnFormat: detectedArnFormat,\n    });\n  }\n\n  /**\n   * Extract the full resource name from an ARN\n   *\n   * Necessary for resource names (paths) that may contain the separator, like\n   * `arn:aws:iam::111111111111:role/path/to/role/name`.\n   *\n   * Only works if we statically know the expected `resourceType` beforehand, since we're going\n   * to use that to split the string on ':<resourceType>/' (and take the right-hand side).\n   *\n   * We can't extract the 'resourceType' from the ARN at hand, because CloudFormation Expressions\n   * only allow literals in the 'separator' argument to `{ Fn::Split }`, and so it can't be\n   * `{ Fn::Select: [5, { Fn::Split: [':', ARN] }}`.\n   *\n   * Only necessary for ARN formats for which the type-name separator is `/`.\n   */\n  public static extractResourceName(arn: string, resourceType: string): string {\n    const components = parseArnShape(arn);\n    if (components === \"token\") {\n      return cdktf.Fn.element(cdktf.Fn.split(`:${resourceType}/`, arn), 1);\n    }\n\n    // Apparently we could just parse this right away. Validate that we got the right\n    // resource type (to notify authors of incorrect assumptions right away).\n    const parsed = Arn.split(arn, ArnFormat.SLASH_RESOURCE_NAME);\n    if (\n      !cdktf.Token.isUnresolved(parsed.resource) &&\n      parsed.resource !== resourceType\n    ) {\n      throw new Error(\n        `Expected resource type '${resourceType}' in ARN, got '${parsed.resource}' in '${arn}'`,\n      );\n    }\n    if (!parsed.resourceName) {\n      throw new Error(\n        `Expected resource name in ARN, didn't find one: '${arn}'`,\n      );\n    }\n    return parsed.resourceName;\n  }\n\n  private constructor() {}\n}\n\n/**\n * Given a Token evaluating to ARN, parses it and returns components.\n *\n * The ARN cannot be validated, since we don't have the actual value yet\n * at the time of this function call. You will have to know the separator\n * and the type of ARN.\n *\n * The resulting `ArnComponents` object will contain tokens for the\n * subexpressions of the ARN, not string literals.\n *\n * WARNING: this function cannot properly parse the complete final\n * 'resourceName' part if it contains colons,\n * like 'arn:aws:cognito-sync:region:account:identitypool/us-east-1:1a1a1a1a-ffff-1111-9999-12345678:bla'.\n *\n * @param arnToken The input token that contains an ARN\n * @param arnFormat the expected format of 'arn' - depends on what format the service the ARN represents uses\n */\nfunction parseTokenArn(arnToken: string, arnFormat: ArnFormat): ArnComponents {\n  // ARN looks like:\n  // arn:partition:service:region:account:resource\n  // arn:partition:service:region:account:resource:resourceName\n  // arn:partition:service:region:account:resource/resourceName\n  // arn:partition:service:region:account:/resource/resourceName\n\n  const components = cdktf.Fn.split(\":\", arnToken);\n\n  const partition = cdktf.Fn.element(components, 1).toString();\n  const service = cdktf.Fn.element(components, 2).toString();\n  const region = cdktf.Fn.element(components, 3).toString();\n  const account = cdktf.Fn.element(components, 4).toString();\n  let resource: string;\n  let resourceName: string | undefined;\n  let sep: string | undefined;\n\n  if (\n    arnFormat === ArnFormat.NO_RESOURCE_NAME ||\n    arnFormat === ArnFormat.COLON_RESOURCE_NAME\n  ) {\n    // we know that the 'resource' part will always be the 6th segment in this case\n    resource = cdktf.Fn.element(components, 5);\n    if (arnFormat === ArnFormat.COLON_RESOURCE_NAME) {\n      resourceName = cdktf.Fn.element(components, 6);\n      sep = \":\";\n    } else {\n      resourceName = undefined;\n      sep = undefined;\n    }\n  } else {\n    // we know that the 'resource' and 'resourceName' parts are separated by slash here,\n    // so we split the 6th segment from the colon-separated ones with a slash\n    const lastComponents = cdktf.Fn.split(\"/\", cdktf.Fn.element(components, 5));\n\n    if (arnFormat === ArnFormat.SLASH_RESOURCE_NAME) {\n      resource = cdktf.Fn.element(lastComponents, 0);\n      resourceName = cdktf.Fn.element(lastComponents, 1);\n    } else {\n      // arnFormat is ArnFormat.SLASH_RESOURCE_SLASH_RESOURCE_NAME,\n      // which means there's an extra slash there at the beginning that we need to skip\n      resource = cdktf.Fn.element(lastComponents, 1);\n      resourceName = cdktf.Fn.element(lastComponents, 2);\n    }\n    sep = \"/\";\n  }\n\n  return {\n    partition,\n    service,\n    region,\n    account,\n    resource,\n    resourceName,\n    sep,\n    arnFormat,\n  };\n}\n\n/**\n * Validate that a string is either unparseable or looks mostly like an ARN\n */\nfunction parseArnShape(arn: string): \"token\" | string[] {\n  // assume anything that starts with 'arn:' is an ARN,\n  // so we can report better errors\n  const looksLikeArn = arn.startsWith(\"arn:\");\n\n  if (!looksLikeArn) {\n    if (cdktf.Token.isUnresolved(arn)) {\n      return \"token\";\n    } else {\n      throw new Error(\n        `ARNs must start with \"arn:\" and have at least 6 components: ${arn}`,\n      );\n    }\n  }\n\n  // If the ARN merely contains Tokens, but otherwise *looks* mostly like an ARN,\n  // it's a string of the form 'arn:${partition}:service:${region}:${account}:resource/xyz'.\n  // Parse fields out to the best of our ability.\n  // Tokens won't contain \":\", so this won't break them.\n  const components = arn.split(\":\");\n\n  const partition = components.length > 1 ? components[1] : undefined;\n  if (!partition) {\n    throw new Error(\n      \"The `partition` component (2nd component) of an ARN is required: \" + arn,\n    );\n  }\n\n  const service = components.length > 2 ? components[2] : undefined;\n  if (!service) {\n    throw new Error(\n      \"The `service` component (3rd component) of an ARN is required: \" + arn,\n    );\n  }\n\n  const resource = components.length > 5 ? components[5] : undefined;\n  if (!resource) {\n    throw new Error(\n      \"The `resource` component (6th component) of an ARN is required: \" + arn,\n    );\n  }\n\n  // Region can be missing in global ARNs (such as used by IAM)\n\n  // Account can be missing in some ARN types (such as used for S3 buckets)\n\n  return components;\n}\n"]}