terraconstructs 0.0.8

package/lib/aws/iam/principals.js

@@ -0,0 +1,1032 @@
+"use strict";
+var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergePrincipal = exports.defaultAddPrincipalToAssumeRole = exports.SessionTagsPrincipal = exports.PrincipalWithConditions = exports.ComparablePrincipal = exports.CompositePrincipal = exports.StarPrincipal = exports.Anyone = exports.AnyPrincipal = exports.AccountRootPrincipal = exports.SamlConsolePrincipal = exports.SamlPrincipal = exports.OpenIdConnectPrincipal = exports.WebIdentityPrincipal = exports.FederatedPrincipal = exports.CanonicalUserPrincipal = exports.OrganizationPrincipal = exports.ServicePrincipal = exports.AccountPrincipal = exports.ArnPrincipal = exports.PrincipalBase = exports.toPrincipalJson = exports.fromPrincipalJson = exports.PrincipalPolicyFragment = exports.PrincipalType = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdktf_1 = require("cdktf");
+const aws_stack_1 = require("../aws-stack");
+const policy_statement_1 = require("./policy-statement");
+var PrincipalType;
+(function (PrincipalType) {
+    PrincipalType["AWS"] = "AWS";
+    PrincipalType["FEDERATED"] = "Federated";
+    PrincipalType["SERVICE"] = "Service";
+    PrincipalType["CANONICALUSER"] = "CanonicalUser";
+    PrincipalType["ANY"] = "*";
+})(PrincipalType || (exports.PrincipalType = PrincipalType = {}));
+function isValidPrincipalType(value) {
+    const upperCaseValue = value.toUpperCase();
+    return upperCaseValue in PrincipalType;
+}
+/**
+ * A collection of the fields in a PolicyStatement that can be used to identify a principal.
+ *
+ * This consists of the Terraform PrincipalProps representing the
+ * `principals` block(s) in a policy statement.
+ *
+ * Generally, AWS principal JSON looks like:
+ *
+ *     { '<TYPE>': ['ID', 'ID', ...] }
+ *
+ * And this is also the type of the field `principalJson`.
+ *
+ * However, there is a special type of principal that is just the string '*',
+ * which is treated differently by some services.
+ *
+ * To represent that principal, `principalJson` should contain `*`.
+ * To represent that principal in Terraform principals block(s), the
+ * type should be `PrincipalType.ANY` and the identifiers should be `['*']`.
+ */
+class PrincipalPolicyFragment {
+    /**
+     * Parses a JSON object with the AWS IAM Principal structure
+     *
+     * Refer to the `fromPrincipalJson` and `fromConditionJson` functions for more information
+     */
+    static fromJson(principalJson, conditionsJson = {}) {
+        return new PrincipalPolicyFragment(fromPrincipalJson(principalJson), (0, policy_statement_1.fromConditionJson)(conditionsJson));
+    }
+    // TODO: Should this actually be used anywhere?
+    get principalJson() {
+        return toPrincipalJson(...this.principals);
+    }
+    get conditionsJson() {
+        return (0, policy_statement_1.toConditionJson)(...this.conditions);
+    }
+    /**
+     *
+     * @param principals Array of "principals" block in a policy statement
+     * @param conditions conditions that need to be applied to this policy
+     */
+    constructor(principals, 
+    /**
+     * The conditions under which the policy is in effect.
+     * See [the IAM documentation](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html).
+     */
+    conditions = []) {
+        this.principals = principals;
+        this.conditions = conditions;
+    }
+}
+exports.PrincipalPolicyFragment = PrincipalPolicyFragment;
+_a = JSII_RTTI_SYMBOL_1;
+PrincipalPolicyFragment[_a] = { fqn: "terraconstructs.aws.iam.PrincipalPolicyFragment", version: "0.0.8" };
+/**
+ * Read from AWS Principal JSON to Terraform principals block(s)
+ *
+ * Handles special case: if principal is "*" and turns it into the `StarPrincipal`,
+ *
+ * Even though the IAM Documentation states that "Principal": "*" and "Principal": {"AWS": "*"} are equivalent,
+ * those principal elements have different behavior in some situations, e.g., IAM Role Trust Policy.
+ *
+ * To have Terraform render JSON containing "Principal": "*", use type = "*" and identifiers = ["*"].
+ * To have Terraform render JSON containing "Principal": {"AWS": "*"}, use type = "AWS" and identifiers = ["*"].
+ */
+function fromPrincipalJson(principalJson = {}) {
+    if (typeof principalJson === "string") {
+        if (principalJson === "*") {
+            return [{ type: PrincipalType.ANY, identifiers: ["*"] }];
+        }
+        else {
+            // TODO: Should this handle other scenarios (i.e. Tokens?)
+            throw new Error(`Invalid principal type: ${principalJson}`);
+        }
+    }
+    if (typeof principalJson !== "object") {
+        throw new Error(`JSON IAM principal should be an object, got ${JSON.stringify(principalJson)}`);
+    }
+    const result = new Array();
+    for (const [key, identifiers] of Object.entries(principalJson)) {
+        if (!isValidPrincipalType(key)) {
+            throw new Error(`Invalid principal type: ${key}, valid values are: ${Object.values(PrincipalType)}`);
+        }
+        result.push({
+            identifiers: Array.isArray(identifiers) ? identifiers : [identifiers],
+            type: key,
+        });
+    }
+    return result;
+}
+exports.fromPrincipalJson = fromPrincipalJson;
+/**
+ * Convert Terraform principals blocks back to AWS Principal JSON
+ */
+function toPrincipalJson(...principalProps) {
+    if (principalProps.length === 1 &&
+        principalProps[0].type === PrincipalType.ANY &&
+        principalProps[0].identifiers.length === 1 &&
+        principalProps[0].identifiers[0] === "*")
+        return "*";
+    const result = {};
+    for (const principal of principalProps) {
+        result[principal.type] =
+            principal.identifiers.length === 1
+                ? principal.identifiers[0]
+                : principal.identifiers;
+    }
+    return result;
+}
+exports.toPrincipalJson = toPrincipalJson;
+/**
+ * Base class for policy principals
+ */
+class PrincipalBase {
+    constructor() {
+        this.grantPrincipal = this;
+        this.principalAccount = undefined;
+        /**
+         * When this Principal is used in an AssumeRole policy, the action to use.
+         */
+        this.assumeRoleAction = "sts:AssumeRole";
+    }
+    addToPolicy(statement) {
+        return this.addToPrincipalPolicy(statement).statementAdded;
+    }
+    addToPrincipalPolicy(_statement) {
+        // This base class is used for non-identity principals. None of them
+        // have a PolicyDocument to add to.
+        return { statementAdded: false };
+    }
+    addToAssumeRolePolicy(document) {
+        // Default implementation of this protocol
+        document.addStatements(new policy_statement_1.PolicyStatement({
+            actions: [this.assumeRoleAction],
+            principals: [this],
+        }));
+    }
+    toString() {
+        // This is a first pass to make the object readable. Descendant principals
+        // should return something nicer.
+        return JSON.stringify(this.policyFragment.principalJson);
+    }
+    /**
+     * JSON-ify the principal
+     *
+     * Used when JSON.stringify() is called
+     */
+    toJSON() {
+        // Have to implement toJSON() because the default will lead to infinite recursion.
+        return this.policyFragment.principalJson;
+    }
+    /**
+     * Returns a new PrincipalWithConditions using this principal as the base, with the
+     * passed conditions added.
+     *
+     * When there is a value for the same operator and key in both the principal and the
+     * conditions parameter, the value from the conditions parameter will be used.
+     *
+     * @returns a new PrincipalWithConditions object.
+     */
+    withConditions(...conditions) {
+        return new PrincipalWithConditions(this, conditions);
+    }
+    /**
+     * Returns a new principal using this principal as the base, with session tags enabled.
+     *
+     * @returns a new SessionTagsPrincipal object.
+     */
+    withSessionTags() {
+        return new SessionTagsPrincipal(this);
+    }
+}
+exports.PrincipalBase = PrincipalBase;
+_b = JSII_RTTI_SYMBOL_1;
+PrincipalBase[_b] = { fqn: "terraconstructs.aws.iam.PrincipalBase", version: "0.0.8" };
+/**
+ * Specify a principal by the Amazon Resource Name (ARN).
+ * You can specify AWS accounts, IAM users, Federated SAML users, IAM roles, and specific assumed-role sessions.
+ * You cannot specify IAM groups or instance profiles as principals
+ *
+ * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html
+ */
+class ArnPrincipal extends PrincipalBase {
+    /**
+     *
+     * @param arn Amazon Resource Name (ARN) of the principal entity (i.e. arn:aws:iam::123456789012:user/user-name)
+     */
+    constructor(arn) {
+        super();
+        this.arn = arn;
+    }
+    get policyFragment() {
+        return new PrincipalPolicyFragment([
+            {
+                type: PrincipalType.AWS,
+                identifiers: [this.arn],
+            },
+        ]);
+    }
+    toString() {
+        return `ArnPrincipal(${this.arn})`;
+    }
+    /**
+     * A convenience method for adding a condition that the principal is part of the specified
+     * AWS Organization.
+     */
+    inOrganization(organizationId) {
+        return this.withConditions({
+            test: "StringEquals",
+            variable: "aws:PrincipalOrgID",
+            values: [organizationId],
+        });
+    }
+    dedupeString() {
+        return `ArnPrincipal:${this.arn}`;
+    }
+}
+exports.ArnPrincipal = ArnPrincipal;
+_c = JSII_RTTI_SYMBOL_1;
+ArnPrincipal[_c] = { fqn: "terraconstructs.aws.iam.ArnPrincipal", version: "0.0.8" };
+/**
+ * Specify AWS account ID as the principal entity in a policy to delegate authority to the account.
+ */
+class AccountPrincipal extends ArnPrincipal {
+    /**
+     *
+     * @param accountId AWS account ID (i.e. '123456789012')
+     */
+    constructor(accountId) {
+        super(new AwsStackDependentToken((awsStack) => `arn:${awsStack.partition}:iam::${accountId}:root`).toString());
+        this.accountId = accountId;
+        if (!cdktf_1.Token.isUnresolved(accountId) && typeof accountId !== "string") {
+            throw new Error("accountId should be of type string");
+        }
+        this.principalAccount = accountId;
+    }
+    toString() {
+        return `AccountPrincipal(${this.accountId})`;
+    }
+}
+exports.AccountPrincipal = AccountPrincipal;
+_d = JSII_RTTI_SYMBOL_1;
+AccountPrincipal[_d] = { fqn: "terraconstructs.aws.iam.AccountPrincipal", version: "0.0.8" };
+/**
+ * An IAM principal that represents an AWS service (i.e. `sqs.amazonaws.com`).
+ */
+class ServicePrincipal extends PrincipalBase {
+    /**
+     * Return the service principal name based on the region it's used in.
+     *
+     * Some service principal names used to be different for different partitions,
+     * and some were not.
+     *
+     * These days all service principal names are standardized, and they are all
+     * of the form `<servicename>.amazonaws.com`.
+     *
+     * To avoid breaking changes, handling is provided for services added with the formats below,
+     * however, no additional handling will be added for new regions or partitions.
+     *   - s3
+     *   - s3.amazonaws.com
+     *   - s3.amazonaws.com.cn
+     *   - s3.c2s.ic.gov
+     *   - s3.sc2s.sgov.gov
+     *
+     * @example
+     * const principalName = iam.ServicePrincipal.servicePrincipalName('ec2');
+     */
+    static servicePrincipalName(service) {
+        return new ServicePrincipalToken(service, {}).toString();
+    }
+    /**
+     * Reference an AWS service, optionally in a given region
+     *
+     * @param service AWS service (i.e. sqs.amazonaws.com)
+     */
+    constructor(service, opts = {}) {
+        super();
+        this.service = service;
+        this.opts = opts;
+    }
+    get policyFragment() {
+        return new PrincipalPolicyFragment([
+            {
+                type: PrincipalType.SERVICE,
+                identifiers: [
+                    new ServicePrincipalToken(this.service, this.opts).toString(),
+                ],
+            },
+        ], this.opts.conditions);
+    }
+    toString() {
+        return `ServicePrincipal(${this.service})`;
+    }
+    dedupeString() {
+        return `ServicePrincipal:${this.service}:${JSON.stringify(this.opts)}`;
+    }
+}
+exports.ServicePrincipal = ServicePrincipal;
+_e = JSII_RTTI_SYMBOL_1;
+ServicePrincipal[_e] = { fqn: "terraconstructs.aws.iam.ServicePrincipal", version: "0.0.8" };
+/**
+ * A principal that represents an AWS Organization
+ */
+class OrganizationPrincipal extends PrincipalBase {
+    /**
+     *
+     * @param organizationId The unique identifier (ID) of an organization (i.e. o-12345abcde)
+     */
+    constructor(organizationId) {
+        super();
+        this.organizationId = organizationId;
+    }
+    get policyFragment() {
+        return new PrincipalPolicyFragment([{ type: PrincipalType.AWS, identifiers: ["*"] }], [
+            {
+                test: "StringEquals",
+                variable: "aws:PrincipalOrgID",
+                values: [this.organizationId],
+            },
+        ]);
+    }
+    toString() {
+        return `OrganizationPrincipal(${this.organizationId})`;
+    }
+    dedupeString() {
+        return `OrganizationPrincipal:${this.organizationId}`;
+    }
+}
+exports.OrganizationPrincipal = OrganizationPrincipal;
+_f = JSII_RTTI_SYMBOL_1;
+OrganizationPrincipal[_f] = { fqn: "terraconstructs.aws.iam.OrganizationPrincipal", version: "0.0.8" };
+/**
+ * A policy principal for canonicalUserIds - useful for S3 bucket policies that use
+ * Origin Access identities.
+ *
+ * See https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html
+ *
+ * and
+ *
+ * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-restricting-access-to-s3.html
+ *
+ * for more details.
+ *
+ */
+class CanonicalUserPrincipal extends PrincipalBase {
+    /**
+     *
+     * @param canonicalUserId unique identifier assigned by AWS for every account.
+     *   root user and IAM users for an account all see the same ID.
+     *   (i.e. 79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be)
+     */
+    constructor(canonicalUserId) {
+        super();
+        this.canonicalUserId = canonicalUserId;
+    }
+    get policyFragment() {
+        return new PrincipalPolicyFragment([
+            {
+                type: PrincipalType.CANONICALUSER,
+                identifiers: [this.canonicalUserId],
+            },
+        ]);
+    }
+    toString() {
+        return `CanonicalUserPrincipal(${this.canonicalUserId})`;
+    }
+    dedupeString() {
+        return `CanonicalUserPrincipal:${this.canonicalUserId}`;
+    }
+}
+exports.CanonicalUserPrincipal = CanonicalUserPrincipal;
+_g = JSII_RTTI_SYMBOL_1;
+CanonicalUserPrincipal[_g] = { fqn: "terraconstructs.aws.iam.CanonicalUserPrincipal", version: "0.0.8" };
+/**
+ * Principal entity that represents a federated identity provider such as Amazon Cognito,
+ * that can be used to provide temporary security credentials to users who have been authenticated.
+ * Additional condition keys are available when the temporary security credentials are used to make a request.
+ * You can use these keys to write policies that limit the access of federated users.
+ *
+ * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html#condition-keys-wif
+ */
+class FederatedPrincipal extends PrincipalBase {
+    /**
+     *
+     * @param federated federated identity provider (i.e. 'cognito-identity.amazonaws.com' for users authenticated through Cognito)
+     * @param sessionTags Whether to enable session tagging (see https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html)
+     */
+    constructor(federated, conditions = [], assumeRoleAction = "sts:AssumeRole") {
+        super();
+        this.federated = federated;
+        this.conditions = conditions;
+        this.assumeRoleAction = assumeRoleAction;
+    }
+    get policyFragment() {
+        return new PrincipalPolicyFragment([{ type: PrincipalType.FEDERATED, identifiers: [this.federated] }], this.conditions);
+    }
+    toString() {
+        return `FederatedPrincipal(${this.federated})`;
+    }
+    dedupeString() {
+        return `FederatedPrincipal:${this.federated}:${this.assumeRoleAction}:${JSON.stringify(this.conditions)}`;
+    }
+}
+exports.FederatedPrincipal = FederatedPrincipal;
+_h = JSII_RTTI_SYMBOL_1;
+FederatedPrincipal[_h] = { fqn: "terraconstructs.aws.iam.FederatedPrincipal", version: "0.0.8" };
+/**
+ * A principal that represents a federated identity provider as Web Identity such as Cognito, Amazon,
+ * Facebook, Google, etc.
+ */
+class WebIdentityPrincipal extends FederatedPrincipal {
+    /**
+     *
+     * @param identityProvider identity provider (i.e. 'cognito-identity.amazonaws.com' for users authenticated through Cognito)
+     * @param conditions The conditions under which the policy is in effect.
+     *   See [the IAM documentation](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html).
+     * @param sessionTags Whether to enable session tagging (see https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html)
+     */
+    constructor(identityProvider, conditions = []) {
+        super(identityProvider, conditions ?? {}, "sts:AssumeRoleWithWebIdentity");
+    }
+    get policyFragment() {
+        return new PrincipalPolicyFragment([{ type: PrincipalType.FEDERATED, identifiers: [this.federated] }], this.conditions);
+    }
+    toString() {
+        return `WebIdentityPrincipal(${this.federated})`;
+    }
+}
+exports.WebIdentityPrincipal = WebIdentityPrincipal;
+_j = JSII_RTTI_SYMBOL_1;
+WebIdentityPrincipal[_j] = { fqn: "terraconstructs.aws.iam.WebIdentityPrincipal", version: "0.0.8" };
+/**
+ * A principal that represents a federated identity provider as from a OpenID Connect provider.
+ */
+class OpenIdConnectPrincipal extends WebIdentityPrincipal {
+    /**
+     *
+     * @param openIdConnectProvider OpenID Connect provider
+     * @param conditions The conditions under which the policy is in effect.
+     *   See [the IAM documentation](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html).
+     */
+    constructor(openIdConnectProvider, conditions = []) {
+        super(openIdConnectProvider.openIdConnectProviderArn, conditions);
+    }
+    get policyFragment() {
+        return new PrincipalPolicyFragment([{ type: PrincipalType.FEDERATED, identifiers: [this.federated] }], this.conditions);
+    }
+    toString() {
+        return `OpenIdConnectPrincipal(${this.federated})`;
+    }
+}
+exports.OpenIdConnectPrincipal = OpenIdConnectPrincipal;
+_k = JSII_RTTI_SYMBOL_1;
+OpenIdConnectPrincipal[_k] = { fqn: "terraconstructs.aws.iam.OpenIdConnectPrincipal", version: "0.0.8" };
+/**
+ * Principal entity that represents a SAML federated identity provider
+ */
+class SamlPrincipal extends FederatedPrincipal {
+    constructor(samlProvider, conditions) {
+        super(samlProvider.samlProviderArn, conditions, "sts:AssumeRoleWithSAML");
+    }
+    toString() {
+        return `SamlPrincipal(${this.federated})`;
+    }
+}
+exports.SamlPrincipal = SamlPrincipal;
+_l = JSII_RTTI_SYMBOL_1;
+SamlPrincipal[_l] = { fqn: "terraconstructs.aws.iam.SamlPrincipal", version: "0.0.8" };
+/**
+ * Principal entity that represents a SAML federated identity provider for
+ * programmatic and AWS Management Console access.
+ */
+class SamlConsolePrincipal extends SamlPrincipal {
+    /**
+     * enum Partition {
+     *   Default = 'aws',
+     *   Cn = 'aws-cn',
+     *   UsGov = 'aws-us-gov',
+     *   UsIso = 'aws-iso',
+     *   UsIsoB = 'aws-iso-b',
+     *   UsIsoF = 'aws-iso-f',
+     *   EuIsoE = 'aws-iso-e',
+     * }
+     * SAML Sign On urls could be...
+     * [Partition.Default]: 'https://signin.aws.amazon.com/saml',
+     * [Partition.Cn]: 'https://signin.amazonaws.cn/saml',
+     * [Partition.UsGov]: 'https://signin.amazonaws-us-gov.com/saml',
+     * [Partition.UsIso]: 'https://signin.c2shome.ic.gov/saml',
+     * [Partition.UsIsoB]: 'https://signin.sc2shome.sgov.gov/saml',
+     */
+    /**
+     * @param samlProvider The SAML provider
+     */
+    constructor(samlProvider, conditions = []) {
+        super(samlProvider, [
+            ...conditions,
+            // TODO: handle collisions on "SAML:aud"?
+            {
+                test: "StringEquals",
+                variable: "SAML:aud",
+                values: ["https://signin.aws.amazon.com/saml"],
+            },
+        ]);
+    }
+    toString() {
+        return `SamlConsolePrincipal(${this.federated})`;
+    }
+}
+exports.SamlConsolePrincipal = SamlConsolePrincipal;
+_m = JSII_RTTI_SYMBOL_1;
+SamlConsolePrincipal[_m] = { fqn: "terraconstructs.aws.iam.SamlConsolePrincipal", version: "0.0.8" };
+/**
+ * Use the AWS account into which a stack is deployed as the principal entity in a policy
+ */
+class AccountRootPrincipal extends AccountPrincipal {
+    constructor() {
+        super(new AwsStackDependentToken((awsStack) => awsStack.account).toString());
+    }
+    toString() {
+        return "AccountRootPrincipal()";
+    }
+}
+exports.AccountRootPrincipal = AccountRootPrincipal;
+_o = JSII_RTTI_SYMBOL_1;
+AccountRootPrincipal[_o] = { fqn: "terraconstructs.aws.iam.AccountRootPrincipal", version: "0.0.8" };
+/**
+ * A principal representing all AWS identities in all accounts
+ *
+ * Some services behave differently when you specify `Principal: '*'`
+ * or `Principal: { AWS: "*" }` in their resource policy.
+ *
+ * `AnyPrincipal` renders to `Principal: { AWS: "*" }`. This is correct
+ * most of the time, but in cases where you need the other principal,
+ * use `StarPrincipal` instead.
+ */
+class AnyPrincipal extends ArnPrincipal {
+    constructor() {
+        super("*");
+    }
+    toString() {
+        return "AnyPrincipal()";
+    }
+}
+exports.AnyPrincipal = AnyPrincipal;
+_p = JSII_RTTI_SYMBOL_1;
+AnyPrincipal[_p] = { fqn: "terraconstructs.aws.iam.AnyPrincipal", version: "0.0.8" };
+/**
+ * A principal representing all identities in all accounts
+ * @deprecated use `AnyPrincipal`
+ */
+class Anyone extends AnyPrincipal {
+}
+exports.Anyone = Anyone;
+_q = JSII_RTTI_SYMBOL_1;
+Anyone[_q] = { fqn: "terraconstructs.aws.iam.Anyone", version: "0.0.8" };
+/**
+ * A principal that uses a literal '*' in the IAM JSON language
+ *
+ * Some services behave differently when you specify `Principal: "*"`
+ * or `Principal: { AWS: "*" }` in their resource policy.
+ *
+ * `StarPrincipal` renders to `Principal: *`. Most of the time, you
+ * should use `AnyPrincipal` instead.
+ */
+class StarPrincipal extends PrincipalBase {
+    constructor() {
+        super(...arguments);
+        this.policyFragment = new PrincipalPolicyFragment([
+            {
+                type: PrincipalType.ANY,
+                identifiers: ["*"],
+            },
+        ]);
+    }
+    toString() {
+        return "StarPrincipal()";
+    }
+    dedupeString() {
+        return "StarPrincipal";
+    }
+}
+exports.StarPrincipal = StarPrincipal;
+_r = JSII_RTTI_SYMBOL_1;
+StarPrincipal[_r] = { fqn: "terraconstructs.aws.iam.StarPrincipal", version: "0.0.8" };
+/**
+ * Represents a principal that has multiple types of principals. A composite principal cannot
+ * have conditions. i.e. multiple ServicePrincipals that form a composite principal
+ */
+class CompositePrincipal extends PrincipalBase {
+    constructor(...principals) {
+        super();
+        this._principals = new Array();
+        if (principals.length === 0) {
+            throw new Error("CompositePrincipals must be constructed with at least 1 Principal but none were passed.");
+        }
+        this.assumeRoleAction = principals[0].assumeRoleAction;
+        this.addPrincipals(...principals);
+    }
+    /**
+     * Adds IAM principals to the composite principal. Composite principals cannot have
+     * conditions.
+     *
+     * @param principals IAM principals that will be added to the composite principal
+     */
+    addPrincipals(...principals) {
+        this._principals.push(...principals);
+        return this;
+    }
+    addToAssumeRolePolicy(doc) {
+        for (const p of this._principals) {
+            defaultAddPrincipalToAssumeRole(p, doc);
+        }
+    }
+    get policyFragment() {
+        // We only have a problem with conditions if we are trying to render composite
+        // principals into a single statement (which is when `policyFragment` would get called)
+        for (const p of this._principals) {
+            const fragment = p.policyFragment;
+            if (fragment.conditions && fragment.conditions.length > 0) {
+                throw new Error("Components of a CompositePrincipal must not have conditions. " +
+                    `Tried to add the following fragment: ${JSON.stringify(fragment)}`);
+            }
+        }
+        const principals = new Array();
+        for (const p of this._principals) {
+            mergePrincipal(principals, p.policyFragment.principals);
+        }
+        return new PrincipalPolicyFragment(principals);
+    }
+    toString() {
+        return `CompositePrincipal(${this._principals})`;
+    }
+    dedupeString() {
+        const inner = this._principals.map(ComparablePrincipal.dedupeStringFor);
+        if (inner.some((x) => x === undefined)) {
+            return undefined;
+        }
+        return `CompositePrincipal[${inner.join(",")}]`;
+    }
+    /**
+     * Returns the principals that make up the CompositePrincipal
+     */
+    get principals() {
+        return this._principals;
+    }
+}
+exports.CompositePrincipal = CompositePrincipal;
+_s = JSII_RTTI_SYMBOL_1;
+CompositePrincipal[_s] = { fqn: "terraconstructs.aws.iam.CompositePrincipal", version: "0.0.8" };
+/**
+ * Base class for Principals that wrap other principals
+ */
+class PrincipalAdapter extends PrincipalBase {
+    constructor(wrapped) {
+        super();
+        this.wrapped = wrapped;
+        this.assumeRoleAction = this.wrapped.assumeRoleAction;
+        this.principalAccount = this.wrapped.principalAccount;
+    }
+    get policyFragment() {
+        return this.wrapped.policyFragment;
+    }
+    addToPrincipalPolicy(statement) {
+        return this.wrapped.addToPrincipalPolicy(statement);
+    }
+    /**
+     * Append the given string to the wrapped principal's dedupe string (if available)
+     */
+    appendDedupe(append) {
+        const inner = ComparablePrincipal.dedupeStringFor(this.wrapped);
+        return inner !== undefined
+            ? `${this.constructor.name}:${inner}:${append}`
+            : undefined;
+    }
+}
+/**
+ * Helper class for working with `IComparablePrincipal`s
+ */
+class ComparablePrincipal {
+    /**
+     * Whether or not the given principal is a comparable principal
+     */
+    static isComparablePrincipal(x) {
+        return "dedupeString" in x;
+    }
+    /**
+     * Return the dedupeString of the given principal, if available
+     */
+    static dedupeStringFor(x) {
+        return ComparablePrincipal.isComparablePrincipal(x)
+            ? x.dedupeString()
+            : undefined;
+    }
+}
+exports.ComparablePrincipal = ComparablePrincipal;
+_t = JSII_RTTI_SYMBOL_1;
+ComparablePrincipal[_t] = { fqn: "terraconstructs.aws.iam.ComparablePrincipal", version: "0.0.8" };
+/**
+ * An IAM principal with additional conditions specifying when the policy is in effect.
+ *
+ * For more information about conditions, see:
+ * https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html
+ */
+class PrincipalWithConditions extends PrincipalAdapter {
+    constructor(principal, conditions) {
+        super(principal);
+        this.additionalConditions = {};
+        for (const c of conditions) {
+            this.addCondition(c);
+        }
+    }
+    // ref: https://github.com/aws/aws-cdk/pull/28510/files#diff-50248f671e9b13a9cb35a62441d72832dca89b6c7ad4a88aa4fb2ec8e676b7cd
+    addToAssumeRolePolicy(doc) {
+        if (doc.node.scope === undefined) {
+            throw new Error("Cannot add a condition to a principal outside of a stack scope");
+        }
+        // Lazy import to avoid circular import dependencies during startup
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const adapter = require("./private/adapter");
+        defaultAddPrincipalToAssumeRole(this.wrapped, new adapter.MutatingPolicyDocumentAdapter(doc, (statement) => {
+            statement.addActions(this.assumeRoleAction);
+            statement.addConditions(...this.conditions);
+            return statement;
+        }));
+    }
+    /**
+     * Add a condition to the principal
+     */
+    addCondition(condition) {
+        if (!this.additionalConditions[condition.test]) {
+            this.additionalConditions[condition.test] = {};
+        }
+        const existingCondition = this.additionalConditions[condition.test][condition.variable];
+        if (existingCondition) {
+            this.additionalConditions[condition.test][condition.variable] = {
+                ...existingCondition,
+                ...condition,
+            };
+        }
+        else {
+            this.additionalConditions[condition.test][condition.variable] = condition;
+        }
+    }
+    /**
+     * Add a conditionObject to the principal
+     *
+     * A conditionObject has the format of test: { variable: value | values[] }
+     *
+     * For example:
+     *
+     * ```ts
+     * const condition1 = {'StringEquals', { 'aws:SomeField': '1' }};
+     * // or
+     * const condition2 = {'StringEquals', { 'aws:SomeField': ['1', '2'] }};
+     * ```
+     */
+    addConditionObject(key, value) {
+        (0, policy_statement_1.validateConditionObject)(value);
+        for (const [k, v] of Object.entries(value)) {
+            if (!(0, policy_statement_1.isStringOrArrayOfStrings)(v)) {
+                throw new Error(`Fields must be either a string or an array of strings. Got ${v} for key ${k}`);
+            }
+            this.addCondition({
+                test: key,
+                variable: k,
+                values: Array.isArray(v) ? v : [v],
+            });
+        }
+    }
+    /**
+     * Adds multiple conditions to the principal
+     *
+     * Values from the conditions parameter will overwrite existing values with the same operator
+     * and key.
+     */
+    addConditions(conditions) {
+        conditions.map((c) => {
+            this.addCondition(c);
+        });
+    }
+    /**
+     * Adds multiple conditionObjects to the principal
+     *
+     * Values from the conditions parameter will overwrite existing values with the same operator
+     * and key.
+     */
+    addConditionObjects(conditions) {
+        for (const [key, value] of Object.entries(conditions)) {
+            this.addConditionObject(key, value);
+        }
+    }
+    /**
+     * The conditions under which the policy is in effect.
+     * See [the IAM documentation](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html).
+     */
+    get conditions() {
+        return this.mergeConditions(this.wrapped.policyFragment.conditions, this.additionalConditions);
+    }
+    get policyFragment() {
+        return new PrincipalPolicyFragment(this.wrapped.policyFragment.principals, this.conditions);
+    }
+    toString() {
+        return this.wrapped.toString();
+    }
+    /**
+     * JSON-ify the principal
+     *
+     * Used when JSON.stringify() is called
+     */
+    toJSON() {
+        // Have to implement toJSON() because the default will lead to infinite recursion.
+        return this.policyFragment.principalJson;
+    }
+    dedupeString() {
+        return this.appendDedupe(JSON.stringify(this.conditions));
+    }
+    mergeConditions(principalConditions, additionalConditions) {
+        const mergedConditions = {};
+        principalConditions.forEach((c) => {
+            if (!mergedConditions[c.test]) {
+                mergedConditions[c.test] = {};
+            }
+            mergedConditions[c.test][c.variable] = c;
+        });
+        Object.entries(additionalConditions).forEach(([test, condition]) => {
+            // merge the conditions if one of the additional conditions uses an
+            // operator that's already used by the principal's conditions merge the
+            // inner structure.
+            const existing = mergedConditions[test];
+            if (!existing) {
+                mergedConditions[test] = condition;
+                return; // continue
+            }
+            // TODO: Support IResolvable Condition?
+            // // if either the existing condition or the new one contain unresolved
+            // // tokens, fail the merge. this is as far as we go at this point.
+            // if (Token.isUnresolved(condition) || Token.isUnresolved(existing)) {
+            //   throw new Error(
+            //     `multiple "${test}" conditions cannot be merged if one of them contains an unresolved token`,
+            //   );
+            // }
+            // TODO: Validate condition?
+            // validateConditionObject(existing);
+            // validateConditionObject(condition);
+            mergedConditions[test] = { ...existing, ...condition };
+        });
+        return (0, policy_statement_1.toConditions)(mergedConditions);
+    }
+}
+exports.PrincipalWithConditions = PrincipalWithConditions;
+_u = JSII_RTTI_SYMBOL_1;
+PrincipalWithConditions[_u] = { fqn: "terraconstructs.aws.iam.PrincipalWithConditions", version: "0.0.8" };
+/**
+ * Enables session tags on role assumptions from a principal
+ *
+ * For more information on session tags, see:
+ * https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html
+ */
+class SessionTagsPrincipal extends PrincipalAdapter {
+    constructor(principal) {
+        super(principal);
+    }
+    // ref: https://github.com/aws/aws-cdk/pull/28510/files#diff-50248f671e9b13a9cb35a62441d72832dca89b6c7ad4a88aa4fb2ec8e676b7cd
+    addToAssumeRolePolicy(doc) {
+        // Lazy import to avoid circular import dependencies during startup
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const adapter = require("./private/adapter");
+        defaultAddPrincipalToAssumeRole(this.wrapped, new adapter.MutatingPolicyDocumentAdapter(doc, (statement) => {
+            statement.addActions("sts:TagSession");
+            return statement;
+        }));
+    }
+    dedupeString() {
+        return this.appendDedupe("");
+    }
+}
+exports.SessionTagsPrincipal = SessionTagsPrincipal;
+_v = JSII_RTTI_SYMBOL_1;
+SessionTagsPrincipal[_v] = { fqn: "terraconstructs.aws.iam.SessionTagsPrincipal", version: "0.0.8" };
+/**
+ * Add a principal to an AssumeRolePolicyDocument in the right way
+ *
+ * Delegate to the principal if it can do the job itself, do a default job if it can't.
+ */
+function defaultAddPrincipalToAssumeRole(principal, doc) {
+    if (isAssumeRolePrincipal(principal)) {
+        // Principal knows how to add itself
+        principal.addToAssumeRolePolicy(doc);
+    }
+    else {
+        // Principal can't add itself, we do it for them
+        doc.addStatements(new policy_statement_1.PolicyStatement({
+            actions: [principal.assumeRoleAction],
+            principals: [principal],
+        }));
+    }
+}
+exports.defaultAddPrincipalToAssumeRole = defaultAddPrincipalToAssumeRole;
+function isAssumeRolePrincipal(principal) {
+    return !!principal.addToAssumeRolePolicy;
+}
+/**
+ * A lazy token that requires an instance of Stack to evaluate
+ */
+class AwsStackDependentToken {
+    constructor(fn) {
+        this.fn = fn;
+        // TODO: Implement stack traces
+        // ref: https://github.com/hashicorp/terraform-cdk/blob/v0.20.9/packages/cdktf/lib/tokens/private/stack-trace.ts#L9
+        // ref: https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/core/lib/stack-trace.ts#L22
+        this.creationStack = ["stack traces disabled"];
+    }
+    resolve(context) {
+        return this.fn(aws_stack_1.AwsStack.ofAwsConstruct(context.scope));
+    }
+    toString() {
+        return cdktf_1.Token.asString(this);
+    }
+    /**
+     * JSON-ify the token
+     *
+     * Used when JSON.stringify() is called
+     */
+    toJSON() {
+        return "<unresolved-token>";
+    }
+}
+class ServicePrincipalToken {
+    constructor(service, opts) {
+        this.service = service;
+        this.opts = opts;
+        // TODO: Implement stack traces
+        // ref: https://github.com/hashicorp/terraform-cdk/blob/v0.20.9/packages/cdktf/lib/tokens/private/stack-trace.ts#L9
+        // ref: https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/core/lib/stack-trace.ts#L22
+        this.creationStack = ["stack traces disabled"];
+    }
+    resolve(ctx) {
+        const awsStack = aws_stack_1.AwsStack.ofAwsConstruct(ctx.scope);
+        // TODO: Does this work for Opt-In regions??
+        // https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-iam/lib/principals.ts#L506-L510
+        return awsStack.servicePrincipalName(this.service, this.opts.region);
+    }
+    toString() {
+        return cdktf_1.Token.asString(this, {
+            displayHint: this.service,
+        });
+    }
+    /**
+     * JSON-ify the token
+     *
+     * Used when JSON.stringify() is called
+     */
+    toJSON() {
+        return `<${this.service}>`;
+    }
+}
+/**
+ * Merge two arrays that represent IAM principals
+ *
+ * Does an in-place merge into target.
+ */
+function mergePrincipal(target, source) {
+    // if one represents the starPrincipal the other one must be empty
+    if ((hasStarPrincipal(target) && source.length > 0) ||
+        (hasStarPrincipal(source) && target.length > 0)) {
+        throw new Error(`Cannot merge principals ${JSON.stringify(target)} and ${JSON.stringify(source)}; if one uses a the StarPrincipal string the other one must be empty`);
+    }
+    const targetMap = new Map();
+    for (const principal of target) {
+        targetMap.set(principal.type, principal);
+    }
+    for (const sourcePrincipal of source) {
+        const { type, identifiers: sourceIdentifiers } = sourcePrincipal;
+        if (targetMap.has(type)) {
+            const targetIndentifierSet = new Set(targetMap.get(type).identifiers);
+            for (const id of sourceIdentifiers) {
+                targetIndentifierSet.add(id);
+            }
+            // Update the target identifiers in-place
+            const index = target.findIndex((principal) => principal.type === type);
+            if (index !== -1) {
+                target[index] = {
+                    type,
+                    identifiers: Array.from(targetIndentifierSet),
+                };
+            }
+        }
+        else {
+            target.push({
+                type,
+                identifiers: [...sourceIdentifiers],
+            });
+        }
+    }
+}
+exports.mergePrincipal = mergePrincipal;
+/**
+ * Detect if the PrincipalProps array contains the StarPrincipal:
+ * type = PrincipalType.ANY and identifiers = ["*"]
+ */
+function hasStarPrincipal(principals) {
+    // TODO: Does having more than 1 principal make sense if one of them is the StarPrincipal?
+    for (let index = 0; index < principals.length; index++) {
+        const principal = principals[index];
+        if (principal.type === PrincipalType.ANY &&
+            principal.identifiers.length === 1 &&
+            principal.identifiers[0] === "*") {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"principals.js","sourceRoot":"","sources":["../../../src/aws/iam/principals.ts"],"names":[],"mappings":"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","sourcesContent":["import { Token, IResolvable, IResolveContext } from \"cdktf\";\nimport { IDependable } from \"constructs\";\nimport { AwsStack } from \"../aws-stack\";\nimport { IOpenIdConnectProvider } from \"./oidc-provider\";\nimport { IPolicyDocument } from \"./policy-document\";\nimport {\n  PolicyStatement,\n  Condition,\n  Conditions,\n  isStringOrArrayOfStrings,\n  toConditionJson,\n  fromConditionJson,\n  validateConditionObject,\n  ConditionMap,\n  toConditions,\n} from \"./policy-statement\";\nimport { ISamlProvider } from \"./saml-provider\";\n/**\n * Terraform Principal Props\n *\n * The `principals` and `not_principals` blocks of a policy statement\n *\n * Ref: https://registry.terraform.io/providers/hashicorp/aws/latest/docs/data-sources/iam_policy_document#principals-and-not_principals\n */\nexport interface PrincipalProps {\n  /**\n   * List of identifiers for principals.\n   *\n   * When type is AWS, these are IAM principal ARNs, e.g., arn:aws:iam::12345678901:role/yak-role.\n   *\n   * When type is Service, these are AWS Service roles, e.g., lambda.amazonaws.com.\n   *\n   * When type is Federated, these are web identity users or SAML provider ARNs,\n   * e.g., accounts.google.com or arn:aws:iam::12345678901:saml-provider/yak-saml-provider.\n   *\n   * When type is CanonicalUser, these are canonical user IDs,\n   * e.g., 79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be.\n   *\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/data-sources/iam_policy_document#identifiers DataAwsIamPolicyDocument#identifiers}\n   */\n  readonly identifiers: string[];\n  /**\n   * Type of principal.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/data-sources/iam_policy_document#type DataAwsIamPolicyDocument#type}\n   */\n  readonly type: PrincipalType;\n}\n\nexport enum PrincipalType {\n  AWS = \"AWS\",\n  FEDERATED = \"Federated\",\n  SERVICE = \"Service\",\n  CANONICALUSER = \"CanonicalUser\",\n  ANY = \"*\",\n}\n\nfunction isValidPrincipalType(value: string): boolean {\n  const upperCaseValue = value.toUpperCase();\n  return upperCaseValue in PrincipalType;\n}\n\n/**\n * Any object that has an associated principal that a permission can be granted to\n */\nexport interface IGrantable {\n  /**\n   * The principal to grant permissions to\n   */\n  readonly grantPrincipal: IPrincipal;\n}\n\n/**\n * Represents a logical IAM principal.\n *\n * An IPrincipal describes a logical entity that can perform AWS API calls\n * against sets of resources, optionally under certain conditions.\n *\n * Examples of simple principals are IAM objects that you create, such\n * as Users or Roles.\n *\n * An example of a more complex principals is a `ServicePrincipal` (such as\n * `new ServicePrincipal(\"sns.amazonaws.com\")`, which represents the Simple\n * Notifications Service).\n *\n * A single logical Principal may also map to a set of physical principals.\n * For example, `new OrganizationPrincipal('o-1234')` represents all\n * identities that are part of the given AWS Organization.\n */\nexport interface IPrincipal extends IGrantable {\n  /**\n   * When this Principal is used in an AssumeRole policy, the action to use.\n   */\n  readonly assumeRoleAction: string;\n\n  /**\n   * Return the policy fragment that identifies this principal in a Policy.\n   */\n  readonly policyFragment: PrincipalPolicyFragment;\n\n  /**\n   * The AWS account ID of this principal.\n   * Can be undefined when the account is not known\n   * (for example, for service principals).\n   * Can be a Token - in that case,\n   * it's assumed to be a reference to the DataAwsCallerIdentity\n   */\n  readonly principalAccount?: string;\n\n  /**\n   * Add to the policy of this principal.\n   *\n   * @returns true if the statement was added, false if the principal in\n   * question does not have a policy document to add the statement to.\n   *\n   * @deprecated Use `addToPrincipalPolicy` instead.\n   */\n  addToPolicy(statement: PolicyStatement): boolean;\n\n  /**\n   * Add to the policy of this principal.\n   */\n  addToPrincipalPolicy(statement: PolicyStatement): AddToPrincipalPolicyResult;\n}\n\n/**\n * A collection of the fields in a PolicyStatement that can be used to identify a principal.\n *\n * This consists of the Terraform PrincipalProps representing the\n * `principals` block(s) in a policy statement.\n *\n * Generally, AWS principal JSON looks like:\n *\n *     { '<TYPE>': ['ID', 'ID', ...] }\n *\n * And this is also the type of the field `principalJson`.\n *\n * However, there is a special type of principal that is just the string '*',\n * which is treated differently by some services.\n *\n * To represent that principal, `principalJson` should contain `*`.\n * To represent that principal in Terraform principals block(s), the\n * type should be `PrincipalType.ANY` and the identifiers should be `['*']`.\n */\nexport class PrincipalPolicyFragment {\n  /**\n   * Parses a JSON object with the AWS IAM Principal structure\n   *\n   * Refer to the `fromPrincipalJson` and `fromConditionJson` functions for more information\n   */\n  public static fromJson(\n    principalJson: any,\n    conditionsJson: { [key: string]: any } = {},\n  ): PrincipalPolicyFragment {\n    return new PrincipalPolicyFragment(\n      fromPrincipalJson(principalJson),\n      fromConditionJson(conditionsJson),\n    );\n  }\n\n  // TODO: Should this actually be used anywhere?\n  public get principalJson(): AwsPrincipalJson {\n    return toPrincipalJson(...this.principals);\n  }\n  public get conditionsJson(): { [key: string]: any } {\n    return toConditionJson(...this.conditions);\n  }\n\n  /**\n   *\n   * @param principals Array of \"principals\" block in a policy statement\n   * @param conditions conditions that need to be applied to this policy\n   */\n  constructor(\n    public readonly principals: Array<PrincipalProps>,\n    /**\n     * The conditions under which the policy is in effect.\n     * See [the IAM documentation](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html).\n     */\n    public readonly conditions: Conditions = [],\n  ) {}\n}\n\n/**\n * Typed representation of AWS Principal JSON\n */\nexport type AwsPrincipalJson = string | { [key: string]: string | string[] };\n\n/**\n * Read from AWS Principal JSON to Terraform principals block(s)\n *\n * Handles special case: if principal is \"*\" and turns it into the `StarPrincipal`,\n *\n * Even though the IAM Documentation states that \"Principal\": \"*\" and \"Principal\": {\"AWS\": \"*\"} are equivalent,\n * those principal elements have different behavior in some situations, e.g., IAM Role Trust Policy.\n *\n * To have Terraform render JSON containing \"Principal\": \"*\", use type = \"*\" and identifiers = [\"*\"].\n * To have Terraform render JSON containing \"Principal\": {\"AWS\": \"*\"}, use type = \"AWS\" and identifiers = [\"*\"].\n */\nexport function fromPrincipalJson(principalJson: any = {}): PrincipalProps[] {\n  if (typeof principalJson === \"string\") {\n    if (principalJson === \"*\") {\n      return [{ type: PrincipalType.ANY, identifiers: [\"*\"] }];\n    } else {\n      // TODO: Should this handle other scenarios (i.e. Tokens?)\n      throw new Error(`Invalid principal type: ${principalJson}`);\n    }\n  }\n  if (typeof principalJson !== \"object\") {\n    throw new Error(\n      `JSON IAM principal should be an object, got ${JSON.stringify(principalJson)}`,\n    );\n  }\n  const result = new Array<PrincipalProps>();\n  for (const [key, identifiers] of Object.entries(principalJson)) {\n    if (!isValidPrincipalType(key)) {\n      throw new Error(\n        `Invalid principal type: ${key}, valid values are: ${Object.values(PrincipalType)}`,\n      );\n    }\n    result.push({\n      identifiers: Array.isArray(identifiers) ? identifiers : [identifiers],\n      type: key as PrincipalType,\n    });\n  }\n  return result;\n}\n\n/**\n * Convert Terraform principals blocks back to AWS Principal JSON\n */\nexport function toPrincipalJson(\n  ...principalProps: PrincipalProps[]\n): AwsPrincipalJson {\n  if (\n    principalProps.length === 1 &&\n    principalProps[0].type === PrincipalType.ANY &&\n    principalProps[0].identifiers.length === 1 &&\n    principalProps[0].identifiers[0] === \"*\"\n  )\n    return \"*\";\n\n  const result: { [key: string]: string | string[] } = {};\n  for (const principal of principalProps) {\n    result[principal.type] =\n      principal.identifiers.length === 1\n        ? principal.identifiers[0]\n        : principal.identifiers;\n  }\n  return result;\n}\n\n/**\n * A type of principal that has more control over its own representation in AssumeRolePolicyDocuments\n *\n * More complex types of identity providers need more control over Role's policy documents\n * than simply `{ Effect: 'Allow', Action: 'AssumeRole', Principal: <Whatever> }`.\n *\n * If that control is necessary, they can implement `IAssumeRolePrincipal` to get full\n * access to a Role's AssumeRolePolicyDocument.\n */\nexport interface IAssumeRolePrincipal extends IPrincipal {\n  /**\n   * Add the principal to the AssumeRolePolicyDocument\n   *\n   * Add the statements to the AssumeRolePolicyDocument necessary to give this principal\n   * permissions to assume the given role.\n   */\n  addToAssumeRolePolicy(document: IPolicyDocument): void;\n}\n\n/**\n * Result of calling `addToPrincipalPolicy`\n */\nexport interface AddToPrincipalPolicyResult {\n  /**\n   * Whether the statement was added to the identity's policies.\n   *\n   */\n  readonly statementAdded: boolean;\n\n  /**\n   * Dependable which allows depending on the policy change being applied\n   *\n   * @default - Required if `statementAdded` is true.\n   */\n  readonly policyDependable?: IDependable;\n}\n\n/**\n * Base class for policy principals\n */\nexport abstract class PrincipalBase implements IAssumeRolePrincipal {\n  public readonly grantPrincipal: IPrincipal = this;\n  public readonly principalAccount: string | undefined = undefined;\n\n  /**\n   * Return the policy fragment that identifies this principal in a Policy.\n   */\n  public abstract readonly policyFragment: PrincipalPolicyFragment;\n\n  /**\n   * When this Principal is used in an AssumeRole policy, the action to use.\n   */\n  public readonly assumeRoleAction: string = \"sts:AssumeRole\";\n\n  public addToPolicy(statement: PolicyStatement): boolean {\n    return this.addToPrincipalPolicy(statement).statementAdded;\n  }\n\n  public addToPrincipalPolicy(\n    _statement: PolicyStatement,\n  ): AddToPrincipalPolicyResult {\n    // This base class is used for non-identity principals. None of them\n    // have a PolicyDocument to add to.\n    return { statementAdded: false };\n  }\n\n  public addToAssumeRolePolicy(document: IPolicyDocument): void {\n    // Default implementation of this protocol\n    document.addStatements(\n      new PolicyStatement({\n        actions: [this.assumeRoleAction],\n        principals: [this],\n      }),\n    );\n  }\n\n  public toString() {\n    // This is a first pass to make the object readable. Descendant principals\n    // should return something nicer.\n    return JSON.stringify(this.policyFragment.principalJson);\n  }\n\n  /**\n   * JSON-ify the principal\n   *\n   * Used when JSON.stringify() is called\n   */\n  public toJSON() {\n    // Have to implement toJSON() because the default will lead to infinite recursion.\n    return this.policyFragment.principalJson;\n  }\n\n  /**\n   * Returns a new PrincipalWithConditions using this principal as the base, with the\n   * passed conditions added.\n   *\n   * When there is a value for the same operator and key in both the principal and the\n   * conditions parameter, the value from the conditions parameter will be used.\n   *\n   * @returns a new PrincipalWithConditions object.\n   */\n  public withConditions(...conditions: Conditions): PrincipalBase {\n    return new PrincipalWithConditions(this, conditions);\n  }\n\n  /**\n   * Returns a new principal using this principal as the base, with session tags enabled.\n   *\n   * @returns a new SessionTagsPrincipal object.\n   */\n  public withSessionTags(): PrincipalBase {\n    return new SessionTagsPrincipal(this);\n  }\n\n  /**\n   * Return whether or not this principal is equal to the given principal\n   */\n  public abstract dedupeString(): string | undefined;\n}\n\n/**\n * Specify a principal by the Amazon Resource Name (ARN).\n * You can specify AWS accounts, IAM users, Federated SAML users, IAM roles, and specific assumed-role sessions.\n * You cannot specify IAM groups or instance profiles as principals\n *\n * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html\n */\nexport class ArnPrincipal extends PrincipalBase {\n  /**\n   *\n   * @param arn Amazon Resource Name (ARN) of the principal entity (i.e. arn:aws:iam::123456789012:user/user-name)\n   */\n  constructor(public readonly arn: string) {\n    super();\n  }\n\n  public get policyFragment(): PrincipalPolicyFragment {\n    return new PrincipalPolicyFragment([\n      {\n        type: PrincipalType.AWS,\n        identifiers: [this.arn],\n      },\n    ]);\n  }\n\n  public toString() {\n    return `ArnPrincipal(${this.arn})`;\n  }\n\n  /**\n   * A convenience method for adding a condition that the principal is part of the specified\n   * AWS Organization.\n   */\n  public inOrganization(organizationId: string) {\n    return this.withConditions({\n      test: \"StringEquals\",\n      variable: \"aws:PrincipalOrgID\",\n      values: [organizationId],\n    });\n  }\n\n  public dedupeString(): string | undefined {\n    return `ArnPrincipal:${this.arn}`;\n  }\n}\n\n/**\n * Specify AWS account ID as the principal entity in a policy to delegate authority to the account.\n */\nexport class AccountPrincipal extends ArnPrincipal {\n  public readonly principalAccount: string | undefined;\n\n  /**\n   *\n   * @param accountId AWS account ID (i.e. '123456789012')\n   */\n  constructor(public readonly accountId: any) {\n    super(\n      new AwsStackDependentToken(\n        (awsStack) => `arn:${awsStack.partition}:iam::${accountId}:root`,\n      ).toString(),\n    );\n    if (!Token.isUnresolved(accountId) && typeof accountId !== \"string\") {\n      throw new Error(\"accountId should be of type string\");\n    }\n    this.principalAccount = accountId;\n  }\n\n  public toString() {\n    return `AccountPrincipal(${this.accountId})`;\n  }\n}\n\n/**\n * Options for a service principal.\n */\nexport interface ServicePrincipalOpts {\n  /**\n   * The region in which you want to reference the service\n   *\n   * This is only necessary for *cross-region* references.\n   *\n   * Note: We always return the full service principal name, including the region.\n   * Normally, the region is only required for *opt-in* regions. In those\n   * cases, the region name needs to be included to reference the correct service principal.\n   * In all other cases, the global service principal name is sufficient.\n   *\n   * @default - the resolving Stack's region.\n   */\n  readonly region?: string;\n\n  /**\n   * Additional conditions to add to the Service Principal\n   *\n   * @default - No conditions\n   */\n  readonly conditions?: Conditions;\n}\n\n/**\n * An IAM principal that represents an AWS service (i.e. `sqs.amazonaws.com`).\n */\nexport class ServicePrincipal extends PrincipalBase {\n  /**\n   * Return the service principal name based on the region it's used in.\n   *\n   * Some service principal names used to be different for different partitions,\n   * and some were not.\n   *\n   * These days all service principal names are standardized, and they are all\n   * of the form `<servicename>.amazonaws.com`.\n   *\n   * To avoid breaking changes, handling is provided for services added with the formats below,\n   * however, no additional handling will be added for new regions or partitions.\n   *   - s3\n   *   - s3.amazonaws.com\n   *   - s3.amazonaws.com.cn\n   *   - s3.c2s.ic.gov\n   *   - s3.sc2s.sgov.gov\n   *\n   * @example\n   * const principalName = iam.ServicePrincipal.servicePrincipalName('ec2');\n   */\n  public static servicePrincipalName(service: string): string {\n    return new ServicePrincipalToken(service, {}).toString();\n  }\n\n  /**\n   * Reference an AWS service, optionally in a given region\n   *\n   * @param service AWS service (i.e. sqs.amazonaws.com)\n   */\n  constructor(\n    public readonly service: string,\n    private readonly opts: ServicePrincipalOpts = {},\n  ) {\n    super();\n  }\n\n  public get policyFragment(): PrincipalPolicyFragment {\n    return new PrincipalPolicyFragment(\n      [\n        {\n          type: PrincipalType.SERVICE,\n          identifiers: [\n            new ServicePrincipalToken(this.service, this.opts).toString(),\n          ],\n        },\n      ],\n      this.opts.conditions,\n    );\n  }\n\n  public toString() {\n    return `ServicePrincipal(${this.service})`;\n  }\n\n  public dedupeString(): string | undefined {\n    return `ServicePrincipal:${this.service}:${JSON.stringify(this.opts)}`;\n  }\n}\n\n/**\n * A principal that represents an AWS Organization\n */\nexport class OrganizationPrincipal extends PrincipalBase {\n  /**\n   *\n   * @param organizationId The unique identifier (ID) of an organization (i.e. o-12345abcde)\n   */\n  constructor(public readonly organizationId: string) {\n    super();\n  }\n\n  public get policyFragment(): PrincipalPolicyFragment {\n    return new PrincipalPolicyFragment(\n      [{ type: PrincipalType.AWS, identifiers: [\"*\"] }],\n      [\n        {\n          test: \"StringEquals\",\n          variable: \"aws:PrincipalOrgID\",\n          values: [this.organizationId],\n        },\n      ],\n    );\n  }\n\n  public toString() {\n    return `OrganizationPrincipal(${this.organizationId})`;\n  }\n\n  public dedupeString(): string | undefined {\n    return `OrganizationPrincipal:${this.organizationId}`;\n  }\n}\n\n/**\n * A policy principal for canonicalUserIds - useful for S3 bucket policies that use\n * Origin Access identities.\n *\n * See https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html\n *\n * and\n *\n * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-restricting-access-to-s3.html\n *\n * for more details.\n *\n */\nexport class CanonicalUserPrincipal extends PrincipalBase {\n  /**\n   *\n   * @param canonicalUserId unique identifier assigned by AWS for every account.\n   *   root user and IAM users for an account all see the same ID.\n   *   (i.e. 79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be)\n   */\n  constructor(public readonly canonicalUserId: string) {\n    super();\n  }\n\n  public get policyFragment(): PrincipalPolicyFragment {\n    return new PrincipalPolicyFragment([\n      {\n        type: PrincipalType.CANONICALUSER,\n        identifiers: [this.canonicalUserId],\n      },\n    ]);\n  }\n\n  public toString() {\n    return `CanonicalUserPrincipal(${this.canonicalUserId})`;\n  }\n\n  public dedupeString(): string | undefined {\n    return `CanonicalUserPrincipal:${this.canonicalUserId}`;\n  }\n}\n\n/**\n * Principal entity that represents a federated identity provider such as Amazon Cognito,\n * that can be used to provide temporary security credentials to users who have been authenticated.\n * Additional condition keys are available when the temporary security credentials are used to make a request.\n * You can use these keys to write policies that limit the access of federated users.\n *\n * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_iam-condition-keys.html#condition-keys-wif\n */\nexport class FederatedPrincipal extends PrincipalBase {\n  public readonly assumeRoleAction: string;\n\n  /**\n   * The conditions under which the policy is in effect.\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html\n   */\n  public readonly conditions: Conditions;\n\n  /**\n   *\n   * @param federated federated identity provider (i.e. 'cognito-identity.amazonaws.com' for users authenticated through Cognito)\n   * @param sessionTags Whether to enable session tagging (see https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html)\n   */\n  constructor(\n    public readonly federated: string,\n    conditions: Conditions = [],\n    assumeRoleAction: string = \"sts:AssumeRole\",\n  ) {\n    super();\n\n    this.conditions = conditions;\n    this.assumeRoleAction = assumeRoleAction;\n  }\n\n  public get policyFragment(): PrincipalPolicyFragment {\n    return new PrincipalPolicyFragment(\n      [{ type: PrincipalType.FEDERATED, identifiers: [this.federated] }],\n      this.conditions,\n    );\n  }\n\n  public toString() {\n    return `FederatedPrincipal(${this.federated})`;\n  }\n\n  public dedupeString(): string | undefined {\n    return `FederatedPrincipal:${this.federated}:${this.assumeRoleAction}:${JSON.stringify(this.conditions)}`;\n  }\n}\n\n/**\n * A principal that represents a federated identity provider as Web Identity such as Cognito, Amazon,\n * Facebook, Google, etc.\n */\nexport class WebIdentityPrincipal extends FederatedPrincipal {\n  /**\n   *\n   * @param identityProvider identity provider (i.e. 'cognito-identity.amazonaws.com' for users authenticated through Cognito)\n   * @param conditions The conditions under which the policy is in effect.\n   *   See [the IAM documentation](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html).\n   * @param sessionTags Whether to enable session tagging (see https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html)\n   */\n  constructor(identityProvider: string, conditions: Conditions = []) {\n    super(identityProvider, conditions ?? {}, \"sts:AssumeRoleWithWebIdentity\");\n  }\n\n  public get policyFragment(): PrincipalPolicyFragment {\n    return new PrincipalPolicyFragment(\n      [{ type: PrincipalType.FEDERATED, identifiers: [this.federated] }],\n      this.conditions,\n    );\n  }\n\n  public toString() {\n    return `WebIdentityPrincipal(${this.federated})`;\n  }\n}\n\n/**\n * A principal that represents a federated identity provider as from a OpenID Connect provider.\n */\nexport class OpenIdConnectPrincipal extends WebIdentityPrincipal {\n  /**\n   *\n   * @param openIdConnectProvider OpenID Connect provider\n   * @param conditions The conditions under which the policy is in effect.\n   *   See [the IAM documentation](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html).\n   */\n  constructor(\n    openIdConnectProvider: IOpenIdConnectProvider,\n    conditions: Conditions = [],\n  ) {\n    super(openIdConnectProvider.openIdConnectProviderArn, conditions);\n  }\n\n  public get policyFragment(): PrincipalPolicyFragment {\n    return new PrincipalPolicyFragment(\n      [{ type: PrincipalType.FEDERATED, identifiers: [this.federated] }],\n      this.conditions,\n    );\n  }\n\n  public toString() {\n    return `OpenIdConnectPrincipal(${this.federated})`;\n  }\n}\n\n/**\n * Principal entity that represents a SAML federated identity provider\n */\nexport class SamlPrincipal extends FederatedPrincipal {\n  constructor(samlProvider: ISamlProvider, conditions: Conditions) {\n    super(samlProvider.samlProviderArn, conditions, \"sts:AssumeRoleWithSAML\");\n  }\n\n  public toString() {\n    return `SamlPrincipal(${this.federated})`;\n  }\n}\n\n/**\n * Principal entity that represents a SAML federated identity provider for\n * programmatic and AWS Management Console access.\n */\nexport class SamlConsolePrincipal extends SamlPrincipal {\n  /**\n   * enum Partition {\n   *   Default = 'aws',\n   *   Cn = 'aws-cn',\n   *   UsGov = 'aws-us-gov',\n   *   UsIso = 'aws-iso',\n   *   UsIsoB = 'aws-iso-b',\n   *   UsIsoF = 'aws-iso-f',\n   *   EuIsoE = 'aws-iso-e',\n   * }\n   * SAML Sign On urls could be...\n   * [Partition.Default]: 'https://signin.aws.amazon.com/saml',\n   * [Partition.Cn]: 'https://signin.amazonaws.cn/saml',\n   * [Partition.UsGov]: 'https://signin.amazonaws-us-gov.com/saml',\n   * [Partition.UsIso]: 'https://signin.c2shome.ic.gov/saml',\n   * [Partition.UsIsoB]: 'https://signin.sc2shome.sgov.gov/saml',\n   */\n\n  /**\n   * @param samlProvider The SAML provider\n   */\n  constructor(samlProvider: ISamlProvider, conditions: Conditions = []) {\n    super(samlProvider, [\n      ...conditions,\n      // TODO: handle collisions on \"SAML:aud\"?\n      {\n        test: \"StringEquals\",\n        variable: \"SAML:aud\",\n        values: [\"https://signin.aws.amazon.com/saml\"],\n      },\n    ]);\n  }\n\n  public toString() {\n    return `SamlConsolePrincipal(${this.federated})`;\n  }\n}\n\n/**\n * Use the AWS account into which a stack is deployed as the principal entity in a policy\n */\nexport class AccountRootPrincipal extends AccountPrincipal {\n  constructor() {\n    super(\n      new AwsStackDependentToken((awsStack) => awsStack.account).toString(),\n    );\n  }\n\n  public toString() {\n    return \"AccountRootPrincipal()\";\n  }\n}\n\n/**\n * A principal representing all AWS identities in all accounts\n *\n * Some services behave differently when you specify `Principal: '*'`\n * or `Principal: { AWS: \"*\" }` in their resource policy.\n *\n * `AnyPrincipal` renders to `Principal: { AWS: \"*\" }`. This is correct\n * most of the time, but in cases where you need the other principal,\n * use `StarPrincipal` instead.\n */\nexport class AnyPrincipal extends ArnPrincipal {\n  constructor() {\n    super(\"*\");\n  }\n\n  public toString() {\n    return \"AnyPrincipal()\";\n  }\n}\n\n/**\n * A principal representing all identities in all accounts\n * @deprecated use `AnyPrincipal`\n */\nexport class Anyone extends AnyPrincipal {}\n\n/**\n * A principal that uses a literal '*' in the IAM JSON language\n *\n * Some services behave differently when you specify `Principal: \"*\"`\n * or `Principal: { AWS: \"*\" }` in their resource policy.\n *\n * `StarPrincipal` renders to `Principal: *`. Most of the time, you\n * should use `AnyPrincipal` instead.\n */\nexport class StarPrincipal extends PrincipalBase {\n  public readonly policyFragment: PrincipalPolicyFragment =\n    new PrincipalPolicyFragment([\n      {\n        type: PrincipalType.ANY,\n        identifiers: [\"*\"],\n      },\n    ]);\n\n  public toString() {\n    return \"StarPrincipal()\";\n  }\n\n  public dedupeString(): string | undefined {\n    return \"StarPrincipal\";\n  }\n}\n\n/**\n * Represents a principal that has multiple types of principals. A composite principal cannot\n * have conditions. i.e. multiple ServicePrincipals that form a composite principal\n */\nexport class CompositePrincipal extends PrincipalBase {\n  public readonly assumeRoleAction: string;\n  private readonly _principals = new Array<IPrincipal>();\n\n  constructor(...principals: IPrincipal[]) {\n    super();\n    if (principals.length === 0) {\n      throw new Error(\n        \"CompositePrincipals must be constructed with at least 1 Principal but none were passed.\",\n      );\n    }\n    this.assumeRoleAction = principals[0].assumeRoleAction;\n    this.addPrincipals(...principals);\n  }\n\n  /**\n   * Adds IAM principals to the composite principal. Composite principals cannot have\n   * conditions.\n   *\n   * @param principals IAM principals that will be added to the composite principal\n   */\n  public addPrincipals(...principals: IPrincipal[]): this {\n    this._principals.push(...principals);\n    return this;\n  }\n\n  public addToAssumeRolePolicy(doc: IPolicyDocument) {\n    for (const p of this._principals) {\n      defaultAddPrincipalToAssumeRole(p, doc);\n    }\n  }\n\n  public get policyFragment(): PrincipalPolicyFragment {\n    // We only have a problem with conditions if we are trying to render composite\n    // principals into a single statement (which is when `policyFragment` would get called)\n    for (const p of this._principals) {\n      const fragment = p.policyFragment;\n      if (fragment.conditions && fragment.conditions.length > 0) {\n        throw new Error(\n          \"Components of a CompositePrincipal must not have conditions. \" +\n            `Tried to add the following fragment: ${JSON.stringify(fragment)}`,\n        );\n      }\n    }\n\n    const principals = new Array<PrincipalProps>();\n    for (const p of this._principals) {\n      mergePrincipal(principals, p.policyFragment.principals);\n    }\n    return new PrincipalPolicyFragment(principals);\n  }\n\n  public toString() {\n    return `CompositePrincipal(${this._principals})`;\n  }\n\n  public dedupeString(): string | undefined {\n    const inner = this._principals.map(ComparablePrincipal.dedupeStringFor);\n    if (inner.some((x) => x === undefined)) {\n      return undefined;\n    }\n    return `CompositePrincipal[${inner.join(\",\")}]`;\n  }\n\n  /**\n   * Returns the principals that make up the CompositePrincipal\n   */\n  public get principals(): IPrincipal[] {\n    return this._principals;\n  }\n}\n\n/**\n * Base class for Principals that wrap other principals\n */\nabstract class PrincipalAdapter extends PrincipalBase {\n  public readonly assumeRoleAction = this.wrapped.assumeRoleAction;\n  public readonly principalAccount = this.wrapped.principalAccount;\n\n  constructor(protected readonly wrapped: IPrincipal) {\n    super();\n  }\n\n  public get policyFragment(): PrincipalPolicyFragment {\n    return this.wrapped.policyFragment;\n  }\n\n  public addToPrincipalPolicy(\n    statement: PolicyStatement,\n  ): AddToPrincipalPolicyResult {\n    return this.wrapped.addToPrincipalPolicy(statement);\n  }\n\n  /**\n   * Append the given string to the wrapped principal's dedupe string (if available)\n   */\n  protected appendDedupe(append: string): string | undefined {\n    const inner = ComparablePrincipal.dedupeStringFor(this.wrapped);\n    return inner !== undefined\n      ? `${this.constructor.name}:${inner}:${append}`\n      : undefined;\n  }\n}\n\n/**\n * Interface for principals that can be compared.\n *\n * This only needs to be implemented for principals that could potentially be value-equal.\n * Identity-equal principals will be handled correctly by default.\n */\nexport interface IComparablePrincipal extends IPrincipal {\n  /**\n   * Return a string format of this principal which should be identical if the two\n   * principals are the same.\n   */\n  dedupeString(): string | undefined;\n}\n\n/**\n * Helper class for working with `IComparablePrincipal`s\n */\nexport class ComparablePrincipal {\n  /**\n   * Whether or not the given principal is a comparable principal\n   */\n  public static isComparablePrincipal(\n    x: IPrincipal,\n  ): x is IComparablePrincipal {\n    return \"dedupeString\" in x;\n  }\n\n  /**\n   * Return the dedupeString of the given principal, if available\n   */\n  public static dedupeStringFor(x: IPrincipal): string | undefined {\n    return ComparablePrincipal.isComparablePrincipal(x)\n      ? x.dedupeString()\n      : undefined;\n  }\n}\n\n/**\n * An IAM principal with additional conditions specifying when the policy is in effect.\n *\n * For more information about conditions, see:\n * https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html\n */\nexport class PrincipalWithConditions extends PrincipalAdapter {\n  private additionalConditions: ConditionMap = {};\n\n  constructor(principal: IPrincipal, conditions: Conditions) {\n    super(principal);\n    for (const c of conditions) {\n      this.addCondition(c);\n    }\n  }\n\n  // ref: https://github.com/aws/aws-cdk/pull/28510/files#diff-50248f671e9b13a9cb35a62441d72832dca89b6c7ad4a88aa4fb2ec8e676b7cd\n  public addToAssumeRolePolicy(doc: IPolicyDocument) {\n    if (doc.node.scope === undefined) {\n      throw new Error(\n        \"Cannot add a condition to a principal outside of a stack scope\",\n      );\n    }\n    // Lazy import to avoid circular import dependencies during startup\n\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const adapter: typeof import(\"./private/adapter\") = require(\"./private/adapter\");\n    defaultAddPrincipalToAssumeRole(\n      this.wrapped,\n      new adapter.MutatingPolicyDocumentAdapter(doc, (statement) => {\n        statement.addActions(this.assumeRoleAction);\n        statement.addConditions(...this.conditions);\n        return statement;\n      }),\n    );\n  }\n\n  /**\n   * Add a condition to the principal\n   */\n  public addCondition(condition: Condition) {\n    if (!this.additionalConditions[condition.test]) {\n      this.additionalConditions[condition.test] = {};\n    }\n\n    const existingCondition =\n      this.additionalConditions[condition.test][condition.variable];\n    if (existingCondition) {\n      this.additionalConditions[condition.test][condition.variable] = {\n        ...existingCondition,\n        ...condition,\n      };\n    } else {\n      this.additionalConditions[condition.test][condition.variable] = condition;\n    }\n  }\n\n  /**\n   * Add a conditionObject to the principal\n   *\n   * A conditionObject has the format of test: { variable: value | values[] }\n   *\n   * For example:\n   *\n   * ```ts\n   * const condition1 = {'StringEquals', { 'aws:SomeField': '1' }};\n   * // or\n   * const condition2 = {'StringEquals', { 'aws:SomeField': ['1', '2'] }};\n   * ```\n   */\n  public addConditionObject(key: string, value: unknown) {\n    validateConditionObject(value);\n    for (const [k, v] of Object.entries(value)) {\n      if (!isStringOrArrayOfStrings(v)) {\n        throw new Error(\n          `Fields must be either a string or an array of strings. Got ${v} for key ${k}`,\n        );\n      }\n      this.addCondition({\n        test: key,\n        variable: k,\n        values: Array.isArray(v) ? v : [v],\n      });\n    }\n  }\n\n  /**\n   * Adds multiple conditions to the principal\n   *\n   * Values from the conditions parameter will overwrite existing values with the same operator\n   * and key.\n   */\n  public addConditions(conditions: Conditions) {\n    conditions.map((c) => {\n      this.addCondition(c);\n    });\n  }\n\n  /**\n   * Adds multiple conditionObjects to the principal\n   *\n   * Values from the conditions parameter will overwrite existing values with the same operator\n   * and key.\n   */\n  public addConditionObjects(conditions: { [key: string]: unknown }) {\n    for (const [key, value] of Object.entries(conditions)) {\n      this.addConditionObject(key, value);\n    }\n  }\n\n  /**\n   * The conditions under which the policy is in effect.\n   * See [the IAM documentation](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html).\n   */\n  public get conditions() {\n    return this.mergeConditions(\n      this.wrapped.policyFragment.conditions,\n      this.additionalConditions,\n    );\n  }\n\n  public get policyFragment(): PrincipalPolicyFragment {\n    return new PrincipalPolicyFragment(\n      this.wrapped.policyFragment.principals,\n      this.conditions,\n    );\n  }\n\n  public toString() {\n    return this.wrapped.toString();\n  }\n\n  /**\n   * JSON-ify the principal\n   *\n   * Used when JSON.stringify() is called\n   */\n  public toJSON() {\n    // Have to implement toJSON() because the default will lead to infinite recursion.\n    return this.policyFragment.principalJson;\n  }\n\n  public dedupeString(): string | undefined {\n    return this.appendDedupe(JSON.stringify(this.conditions));\n  }\n\n  private mergeConditions(\n    principalConditions: Conditions,\n    additionalConditions: ConditionMap,\n  ): Conditions {\n    const mergedConditions: ConditionMap = {};\n    principalConditions.forEach((c) => {\n      if (!mergedConditions[c.test]) {\n        mergedConditions[c.test] = {};\n      }\n      mergedConditions[c.test][c.variable] = c;\n    });\n\n    Object.entries(additionalConditions).forEach(([test, condition]) => {\n      // merge the conditions if one of the additional conditions uses an\n      // operator that's already used by the principal's conditions merge the\n      // inner structure.\n      const existing = mergedConditions[test];\n      if (!existing) {\n        mergedConditions[test] = condition;\n        return; // continue\n      }\n\n      // TODO: Support IResolvable Condition?\n      // // if either the existing condition or the new one contain unresolved\n      // // tokens, fail the merge. this is as far as we go at this point.\n      // if (Token.isUnresolved(condition) || Token.isUnresolved(existing)) {\n      //   throw new Error(\n      //     `multiple \"${test}\" conditions cannot be merged if one of them contains an unresolved token`,\n      //   );\n      // }\n\n      // TODO: Validate condition?\n      // validateConditionObject(existing);\n      // validateConditionObject(condition);\n\n      mergedConditions[test] = { ...existing, ...condition };\n    });\n    return toConditions(mergedConditions);\n  }\n}\n\n/**\n * Enables session tags on role assumptions from a principal\n *\n * For more information on session tags, see:\n * https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html\n */\nexport class SessionTagsPrincipal extends PrincipalAdapter {\n  constructor(principal: IPrincipal) {\n    super(principal);\n  }\n\n  // ref: https://github.com/aws/aws-cdk/pull/28510/files#diff-50248f671e9b13a9cb35a62441d72832dca89b6c7ad4a88aa4fb2ec8e676b7cd\n  public addToAssumeRolePolicy(doc: IPolicyDocument) {\n    // Lazy import to avoid circular import dependencies during startup\n\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const adapter: typeof import(\"./private/adapter\") = require(\"./private/adapter\");\n    defaultAddPrincipalToAssumeRole(\n      this.wrapped,\n      new adapter.MutatingPolicyDocumentAdapter(doc, (statement) => {\n        statement.addActions(\"sts:TagSession\");\n        return statement;\n      }),\n    );\n  }\n\n  public dedupeString(): string | undefined {\n    return this.appendDedupe(\"\");\n  }\n}\n\n/**\n * Add a principal to an AssumeRolePolicyDocument in the right way\n *\n * Delegate to the principal if it can do the job itself, do a default job if it can't.\n */\nexport function defaultAddPrincipalToAssumeRole(\n  principal: IPrincipal,\n  doc: IPolicyDocument,\n) {\n  if (isAssumeRolePrincipal(principal)) {\n    // Principal knows how to add itself\n    principal.addToAssumeRolePolicy(doc);\n  } else {\n    // Principal can't add itself, we do it for them\n    doc.addStatements(\n      new PolicyStatement({\n        actions: [principal.assumeRoleAction],\n        principals: [principal],\n      }),\n    );\n  }\n}\n\nfunction isAssumeRolePrincipal(\n  principal: IPrincipal,\n): principal is IAssumeRolePrincipal {\n  return !!(principal as IAssumeRolePrincipal).addToAssumeRolePolicy;\n}\n\n/**\n * A lazy token that requires an instance of Stack to evaluate\n */\nclass AwsStackDependentToken implements IResolvable {\n  public readonly creationStack: string[];\n  constructor(private readonly fn: (spec: AwsStack) => any) {\n    // TODO: Implement stack traces\n    // ref: https://github.com/hashicorp/terraform-cdk/blob/v0.20.9/packages/cdktf/lib/tokens/private/stack-trace.ts#L9\n    // ref: https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/core/lib/stack-trace.ts#L22\n    this.creationStack = [\"stack traces disabled\"];\n  }\n\n  public resolve(context: IResolveContext) {\n    return this.fn(AwsStack.ofAwsConstruct(context.scope));\n  }\n\n  public toString() {\n    return Token.asString(this);\n  }\n\n  /**\n   * JSON-ify the token\n   *\n   * Used when JSON.stringify() is called\n   */\n  public toJSON() {\n    return \"<unresolved-token>\";\n  }\n}\n\nclass ServicePrincipalToken implements IResolvable {\n  public readonly creationStack: string[];\n  constructor(\n    private readonly service: string,\n    private readonly opts: ServicePrincipalOpts,\n  ) {\n    // TODO: Implement stack traces\n    // ref: https://github.com/hashicorp/terraform-cdk/blob/v0.20.9/packages/cdktf/lib/tokens/private/stack-trace.ts#L9\n    // ref: https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/core/lib/stack-trace.ts#L22\n    this.creationStack = [\"stack traces disabled\"];\n  }\n\n  public resolve(ctx: IResolveContext) {\n    const awsStack = AwsStack.ofAwsConstruct(ctx.scope);\n    // TODO: Does this work for Opt-In regions??\n    // https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-iam/lib/principals.ts#L506-L510\n    return awsStack.servicePrincipalName(this.service, this.opts.region);\n  }\n\n  public toString() {\n    return Token.asString(this, {\n      displayHint: this.service,\n    });\n  }\n\n  /**\n   * JSON-ify the token\n   *\n   * Used when JSON.stringify() is called\n   */\n  public toJSON() {\n    return `<${this.service}>`;\n  }\n}\n\n/**\n * Merge two arrays that represent IAM principals\n *\n * Does an in-place merge into target.\n */\nexport function mergePrincipal(\n  target: PrincipalProps[],\n  source: PrincipalProps[],\n) {\n  // if one represents the starPrincipal the other one must be empty\n  if (\n    (hasStarPrincipal(target) && source.length > 0) ||\n    (hasStarPrincipal(source) && target.length > 0)\n  ) {\n    throw new Error(\n      `Cannot merge principals ${JSON.stringify(target)} and ${JSON.stringify(source)}; if one uses a the StarPrincipal string the other one must be empty`,\n    );\n  }\n\n  const targetMap: Map<PrincipalType, PrincipalProps> = new Map();\n  for (const principal of target) {\n    targetMap.set(principal.type, principal);\n  }\n\n  for (const sourcePrincipal of source) {\n    const { type, identifiers: sourceIdentifiers } = sourcePrincipal;\n    if (targetMap.has(type)) {\n      const targetIndentifierSet = new Set(targetMap.get(type)!.identifiers);\n      for (const id of sourceIdentifiers) {\n        targetIndentifierSet.add(id);\n      }\n      // Update the target identifiers in-place\n      const index = target.findIndex((principal) => principal.type === type);\n      if (index !== -1) {\n        target[index] = {\n          type,\n          identifiers: Array.from(targetIndentifierSet),\n        };\n      }\n    } else {\n      target.push({\n        type,\n        identifiers: [...sourceIdentifiers],\n      });\n    }\n  }\n}\n\n/**\n * Detect if the PrincipalProps array contains the StarPrincipal:\n * type = PrincipalType.ANY and identifiers = [\"*\"]\n */\nfunction hasStarPrincipal(principals: PrincipalProps[]) {\n  // TODO: Does having more than 1 principal make sense if one of them is the StarPrincipal?\n  for (let index = 0; index < principals.length; index++) {\n    const principal = principals[index];\n    if (\n      principal.type === PrincipalType.ANY &&\n      principal.identifiers.length === 1 &&\n      principal.identifiers[0] === \"*\"\n    ) {\n      return true;\n    }\n  }\n  return false;\n}\n"]}