terraconstructs 0.0.8

package/lib/aws/iam/role.js

@@ -0,0 +1,407 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Role = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const arn_1 = require("../arn");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+const grant_1 = require("./grant");
+const policy_1 = require("./policy");
+const policy_document_1 = require("./policy-document");
+const principals_1 = require("./principals");
+const adapter_1 = require("./private/adapter");
+const assume_role_policy_1 = require("./private/assume-role-policy");
+const immutable_role_1 = require("./private/immutable-role");
+const imported_role_1 = require("./private/imported-role");
+// import { PrecreatedRole } from "./private/precreated-role";
+const util_1 = require("./private/util");
+const token_1 = require("../../token");
+// TODO: Re-Add LazyRole?
+// ref: https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-iam/lib/lazy-role.ts
+// TODO: re-implement iam role policy splitting
+// const MAX_INLINE_SIZE = 10000;
+// const MAX_MANAGEDPOL_SIZE = 6000;
+const IAM_ROLE_SYMBOL = Symbol.for("terraconstructs/lib/aws/iam.Role");
+/**
+ * IAM Role
+ *
+ * Defines an IAM role. The role is created with an assume policy document associated with
+ * the specified AWS service principal defined in `serviceAssumeRole`.
+ */
+class Role extends aws_construct_1.AwsConstructBase {
+    /**
+     * Import an external role by ARN.
+     *
+     * If the imported Role ARN is a Token (such as a
+     * `CfnParameter.valueAsString` or a `Fn.importValue()`) *and* the referenced
+     * role has a `path` (like `arn:...:role/AdminRoles/Alice`), the
+     * `roleName` property will not resolve to the correct value. Instead it
+     * will resolve to the first path component. We unfortunately cannot express
+     * the correct calculation of the full path name as a CloudFormation
+     * expression. In this scenario the Role ARN should be supplied without the
+     * `path` in order to resolve the correct role resource.
+     *
+     * @param scope construct scope
+     * @param id construct id
+     * @param roleArn the ARN of the role to import
+     * @param options allow customizing the behavior of the returned role
+     */
+    static fromRoleArn(scope, id, roleArn, options = {}) {
+        const scopeStack = aws_stack_1.AwsStack.ofAwsConstruct(scope);
+        const parsedArn = scopeStack.splitArn(roleArn, arn_1.ArnFormat.SLASH_RESOURCE_NAME);
+        const resourceName = parsedArn.resourceName;
+        const roleAccount = parsedArn.account;
+        // service roles have an ARN like 'arn:aws:iam::<account>:role/service-role/<roleName>'
+        // or 'arn:aws:iam::<account>:role/service-role/servicename.amazonaws.com/service-role/<roleName>'
+        // we want to support these as well, so we just use the element after the last slash as role name
+        const roleName = resourceName.split("/").pop();
+        // if (getCustomizeRolesConfig(scope).enabled) {
+        //   return new PrecreatedRole(scope, id, {
+        //     rolePath: `${scope.node.path}/${id}`,
+        //     role: new ImportedRole(scope, `Import${id}`, {
+        //       account: roleAccount,
+        //       roleArn,
+        //       roleName,
+        //       ...options,
+        //     }),
+        //   });
+        // }
+        if (options.addGrantsToResources !== undefined &&
+            options.mutable !== false) {
+            throw new Error("'addGrantsToResources' can only be passed if 'mutable: false'");
+        }
+        const roleArnAndScopeStackAccountComparison = (0, token_1.tokenCompareStrings)(roleAccount ?? "", scopeStack.account);
+        const equalOrAnyUnresolved = roleArnAndScopeStackAccountComparison === token_1.TokenComparison.SAME ||
+            roleArnAndScopeStackAccountComparison ===
+                token_1.TokenComparison.BOTH_UNRESOLVED ||
+            roleArnAndScopeStackAccountComparison === token_1.TokenComparison.ONE_UNRESOLVED;
+        // if we are returning an immutable role then the 'importedRole' is just a throwaway construct
+        // so give it a different id
+        const mutableRoleId = options.mutable !== false && equalOrAnyUnresolved
+            ? id
+            : `MutableRole${id}`;
+        const importedRole = new imported_role_1.ImportedRole(scope, mutableRoleId, {
+            roleArn,
+            roleName,
+            account: roleAccount,
+            ...options,
+        });
+        // we only return an immutable Role if both accounts were explicitly provided, and different
+        return options.mutable !== false && equalOrAnyUnresolved
+            ? importedRole
+            : new immutable_role_1.ImmutableRole(scope, id, importedRole, options.addGrantsToResources ?? false);
+    }
+    /**
+     * Return whether the given object is a Role
+     */
+    static isRole(x) {
+        return x !== null && typeof x === "object" && IAM_ROLE_SYMBOL in x;
+    }
+    /**
+     * Import an external role by name.
+     *
+     * The imported role is assumed to exist in the same account as the account
+     * the scope's containing Stack is being deployed to.
+  
+     * @param scope construct scope
+     * @param id construct id
+     * @param roleName the name of the role to import
+     * @param options allow customizing the behavior of the returned role
+     */
+    static fromRoleName(scope, id, roleName, options = {}) {
+        return Role.fromRoleArn(scope, id, aws_stack_1.AwsStack.ofAwsConstruct(scope).formatArn({
+            region: "",
+            service: "iam",
+            resource: "role",
+            resourceName: roleName,
+        }), options);
+    }
+    /** Strongly typed Outputs */
+    get roleOutputs() {
+        return {
+            arn: this.roleArn,
+            name: this.roleName,
+        };
+    }
+    get outputs() {
+        return this.roleOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        // TODO: Support custom role creation
+        // https://github.com/aws/aws-cdk/blob/v2.143.0/packages/aws-cdk-lib/aws-iam/lib/role.ts#L355
+        this.grantPrincipal = this;
+        this.principalAccount = this.env.account;
+        this.assumeRoleAction = "sts:AssumeRole";
+        this.managedPolicies = [];
+        this.attachedPolicies = new util_1.AttachedPolicies();
+        if (props.roleName &&
+            !cdktf_1.Token.isUnresolved(props.roleName) &&
+            !/^[\w+=,.@-]{1,64}$/.test(props.roleName)) {
+            throw new Error("Invalid roleName. The name must be a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-. Length must be between 1 and 64 characters.");
+        }
+        if (props.roleName && props.roleNamePrefix) {
+            throw new Error("Cannot specify both 'roleName' and 'roleNamePrefix'. Use only one.");
+        }
+        const externalIds = props.externalIds || [];
+        if (props.externalId) {
+            externalIds.push(props.externalId);
+        }
+        this.assumeRolePolicy = createAssumeRolePolicy(this, "AssumeRolePolicy", props.assumedBy, externalIds);
+        this.managedPolicies.push(...(props.managedPolicies || []));
+        this.inlinePolicies = props.inlinePolicies || {};
+        this.permissionsBoundary = props.permissionsBoundary;
+        const maxSessionDuration = props.maxSessionDuration && props.maxSessionDuration.toSeconds();
+        validateMaxSessionDuration(maxSessionDuration);
+        const description = props.description && props.description?.length > 0
+            ? props.description
+            : undefined;
+        if (description && description.length > 1000) {
+            throw new Error("Role description must be no longer than 1000 characters.");
+        }
+        validateRolePath(props.path);
+        // pre-created role snipped
+        // https://github.com/aws/aws-cdk/blob/v2.143.0/packages/aws-cdk-lib/aws-iam/lib/role.ts#L439
+        const namePrefix = this.stack.uniqueResourceNamePrefix(this, {
+            prefix: props.roleNamePrefix ?? this.gridUUID + "-",
+            allowedSpecialCharacters: "_+=,.@-",
+            maxLength: 64,
+        });
+        this.resource = new provider_aws_1.iamRole.IamRole(this, "Resource", {
+            ...props, // copy over Terraform Meta Arguments from ConstructProps
+            assumeRolePolicy: this.assumeRolePolicy.json,
+            managedPolicyArns: util_1.UniqueStringSet.from(() => this.managedPolicies.map((p) => p.managedPolicyArn)),
+            inlinePolicy: _flatten(this.inlinePolicies),
+            path: props.path,
+            permissionsBoundary: this.permissionsBoundary
+                ? this.permissionsBoundary.managedPolicyArn
+                : undefined,
+            name: props.roleName,
+            namePrefix: !props.roleName ? namePrefix : undefined,
+            maxSessionDuration,
+            description,
+            forceDetachPolicies: props.forceDetachPolicies,
+        });
+        // Stable and unique string identifying the role.
+        this._roleId = this.resource.uniqueId;
+        // TODO: Need to handle cross env ARN refs?
+        // CDK: https://github.com/aws/aws-cdk/blob/v2.143.0/packages/aws-cdk-lib/core/lib/resource.ts#L288
+        this.roleArn = this.resource.arn;
+        // TODO: Need to handle cross env Name refs?
+        // CDK: https://github.com/aws/aws-cdk/blob/v2.143.0/packages/aws-cdk-lib/core/lib/resource.ts#L254
+        this.roleName = this.resource.name;
+        // TODO: Re-add policy splitting?
+        // Aspects.of(this).add({
+        //   visit: (c) => {
+        //     if (c === this) {
+        //       this.splitLargePolicy();
+        //     }
+        //   },
+        // });
+        this.policyFragment = new principals_1.ArnPrincipal(this.roleArn).policyFragment;
+        function _flatten(policies) {
+            if (policies == null || Object.keys(policies).length === 0) {
+                return undefined;
+            }
+            const result = new Array();
+            for (const policyName of Object.keys(policies)) {
+                const policyDocument = policies[policyName];
+                result.push({
+                    name: policyName,
+                    policy: policyDocument.json,
+                });
+            }
+            return result;
+        }
+        this.node.addValidation({ validate: () => this.validateRole() });
+    }
+    /**
+     * Adds a permission to the role's default policy document.
+     * If there is no default policy attached to this role, it will be created.
+     * @param statement The permission statement to add to the policy document
+     */
+    addToPrincipalPolicy(statement) {
+        if (!this.defaultPolicy) {
+            this.defaultPolicy = new policy_1.Policy(this, "DefaultPolicy");
+            this.attachInlinePolicy(this.defaultPolicy);
+        }
+        this.defaultPolicy.addStatements(statement);
+        // // We might split this statement off into a different policy, so we'll need to
+        // // late-bind the dependable.
+        // const policyDependable = new DependencyGroup();
+        // this.dependables.set(statement, policyDependable);
+        return { statementAdded: true, policyDependable: this };
+    }
+    addToPolicy(statement) {
+        return this.addToPrincipalPolicy(statement).statementAdded;
+    }
+    /**
+     * Attaches a managed policy to this role.
+     *
+     * NOTE: Using this method will force the role to take over
+     * exclusive management of the role's ManagedPolicy attachments
+     * These arguments are incompatible with other ways of managing
+     * a role's such as attaching the policy to the role through its
+     * `policy.attachToRole(role)` method.
+     *
+     * If you attempt to manage a role's policies by multiple means,
+     * you will get resource cycling and/or errors.
+     *
+     * ```typescript
+     * const policy1 = new iam.ManagedPolicy(this, 'Policy', {
+     *   managedPolicyName: 'MyPolicy1',
+     *   description: 'A description of the policy',
+     * });
+     * const policy2 = new iam.ManagedPolicy(this, 'Policy', {
+     *   managedPolicyName: 'MyPolicy2',
+     *   description: 'A description of the policy',
+     * });
+     *
+     * const role = new iam.Role(this, 'Role', {
+     *  assumedBy: new iam.ServicePrincipal('sns.amazonaws.com'),
+     * });
+     * // role becomes the manager of all attached policies
+     * role.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName('SecurityAudit'));
+     * role.addManagedPolicy(policy1);
+     *
+     * // this introduces resource cycling
+     * // DON'T DO THIS
+     * policy2.attachToRole(role);
+     *
+     * // DO THIS INSTEAD
+     * role.addManagedPolicy(policy2);
+     * ```
+     * @param policy The the managed policy to attach.
+     */
+    addManagedPolicy(policy) {
+        if (this.managedPolicies.some((mp) => mp.managedPolicyArn === policy.managedPolicyArn)) {
+            return;
+        }
+        this.managedPolicies.push(policy);
+    }
+    /**
+     * Attaches a policy to this role.
+     *
+     * NOTE: Using this method will force the role to take over
+     * exclusive management of the role's inline Policy attachments
+     * These arguments are incompatible with other ways of managing
+     * a role's such as attaching a policy to the role.
+     * If you attempt to manage a role's policies by multiple means,
+     * you will get resource cycling and/or errors.
+     *
+     * @param policy The policy to attach
+     */
+    attachInlinePolicy(policy) {
+        this.attachedPolicies.attach(policy);
+        policy.attachToRole(this);
+    }
+    /**
+     * Grant the actions defined in actions to the identity Principal on this resource.
+     */
+    grant(grantee, ...actions) {
+        return grant_1.Grant.addToPrincipal({
+            grantee,
+            actions,
+            resourceArns: [this.roleArn],
+            scope: this,
+        });
+    }
+    /**
+     * Grant permissions to the given principal to pass this role.
+     */
+    grantPassRole(identity) {
+        return this.grant(identity, "iam:PassRole");
+    }
+    /**
+     * Grant permissions to the given principal to assume this role.
+     */
+    grantAssumeRole(identity) {
+        // Service and account principals must use assumeRolePolicy
+        if (identity instanceof principals_1.ServicePrincipal ||
+            identity instanceof principals_1.AccountPrincipal) {
+            throw new Error("Cannot use a service or account principal with grantAssumeRole, use assumeRolePolicy instead.");
+        }
+        return this.grant(identity, "sts:AssumeRole");
+    }
+    /**
+     * Returns the stable and unique string identifying the role. For example,
+     * AIDAJQABLZS4A3QDU576Q.
+     *
+     * @attribute
+     */
+    get roleId() {
+        return this._roleId;
+    }
+    /**
+     * Return a copy of this Role object whose Policies will not be updated
+     *
+     * Use the object returned by this method if you want this Role to be used by
+     * a construct without it automatically updating the Role's Policies.
+     *
+     * If you do, you are responsible for adding the correct statements to the
+     * Role's policies yourself.
+     */
+    withoutPolicyUpdates(options = {}) {
+        if (!this.immutableRole) {
+            this.immutableRole = new immutable_role_1.ImmutableRole(this.node.scope, `ImmutableRole${this.node.id}`, this, options.addGrantsToResources ?? false);
+        }
+        return this.immutableRole;
+    }
+    validateRole() {
+        const errors = new Array();
+        errors.push(...(this.assumeRolePolicy?.validateForResourcePolicy() ?? []));
+        for (const policy of Object.values(this.inlinePolicies)) {
+            errors.push(...policy.validateForIdentityPolicy());
+        }
+        return errors;
+    }
+}
+exports.Role = Role;
+_a = JSII_RTTI_SYMBOL_1;
+Role[_a] = { fqn: "terraconstructs.aws.iam.Role", version: "0.0.8" };
+function createAssumeRolePolicy(scope, id, principal, externalIds) {
+    const actualDoc = new policy_document_1.PolicyDocument(scope, id);
+    // If requested, add externalIds to every statement added to this doc
+    const addDoc = externalIds.length === 0
+        ? actualDoc
+        : new adapter_1.MutatingPolicyDocumentAdapter(actualDoc, (statement) => {
+            statement.addCondition({
+                test: "StringEquals",
+                variable: "sts:ExternalId",
+                values: externalIds,
+            });
+            return statement;
+        });
+    (0, assume_role_policy_1.defaultAddPrincipalToAssumeRole)(principal, addDoc);
+    return actualDoc;
+}
+function validateRolePath(path) {
+    if (path === undefined || cdktf_1.Token.isUnresolved(path)) {
+        return;
+    }
+    const validRolePath = /^(\/|\/[\u0021-\u007F]+\/)$/;
+    if (path.length == 0 || path.length > 512) {
+        throw new Error(`Role path must be between 1 and 512 characters. The provided role path is ${path.length} characters.`);
+    }
+    else if (!validRolePath.test(path)) {
+        throw new Error("Role path must be either a slash or valid characters (alphanumerics and symbols) surrounded by slashes. " +
+            `Valid characters are unicode characters in [\\u0021-\\u007F]. However, ${path} is provided.`);
+    }
+}
+function validateMaxSessionDuration(duration) {
+    if (duration === undefined) {
+        return;
+    }
+    if (duration < 3600 || duration > 43200) {
+        throw new Error(`maxSessionDuration is set to ${duration}, but must be >= 3600sec (1hr) and <= 43200sec (12hrs)`);
+    }
+}
+Object.defineProperty(Role.prototype, IAM_ROLE_SYMBOL, {
+    value: true,
+    enumerable: false,
+    writable: false,
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"role.js","sourceRoot":"","sources":["../../../src/aws/iam/role.ts"],"names":[],"mappings":"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","sourcesContent":["import { iamRole } from \"@cdktf/provider-aws\";\nimport { Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { ArnFormat } from \"../arn\";\nimport { AwsConstructBase, AwsConstructProps } from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport { Grant } from \"./grant\";\nimport { IIdentity } from \"./identity-base\";\nimport { IManagedPolicy } from \"./managed-policy\";\nimport { Policy } from \"./policy\";\nimport { PolicyDocument } from \"./policy-document\";\nimport { PolicyStatement } from \"./policy-statement\";\nimport {\n  AccountPrincipal,\n  AddToPrincipalPolicyResult,\n  ArnPrincipal,\n  IPrincipal,\n  PrincipalPolicyFragment,\n  ServicePrincipal,\n} from \"./principals\";\nimport { Duration } from \"../..\";\nimport { MutatingPolicyDocumentAdapter } from \"./private/adapter\";\nimport { defaultAddPrincipalToAssumeRole } from \"./private/assume-role-policy\";\nimport { ImmutableRole } from \"./private/immutable-role\";\nimport { ImportedRole } from \"./private/imported-role\";\n// import { PrecreatedRole } from \"./private/precreated-role\";\nimport { AttachedPolicies, UniqueStringSet } from \"./private/util\";\nimport { TokenComparison, tokenCompareStrings } from \"../../token\";\n\n// TODO: Re-Add LazyRole?\n// ref: https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-iam/lib/lazy-role.ts\n\n// TODO: re-implement iam role policy splitting\n// const MAX_INLINE_SIZE = 10000;\n// const MAX_MANAGEDPOL_SIZE = 6000;\nconst IAM_ROLE_SYMBOL = Symbol.for(\"terraconstructs/lib/aws/iam.Role\");\n\n/**\n * Properties for defining an IAM Role\n */\nexport interface RoleProps extends AwsConstructProps {\n  /**\n   * The IAM principal (i.e. `new ServicePrincipal('sns.amazonaws.com')`)\n   * which can assume this role.\n   *\n   * You can later modify the assume role policy document by accessing it via\n   * the `assumeRolePolicy` property.\n   */\n  readonly assumedBy: IPrincipal;\n\n  /**\n   * ID that the role assumer needs to provide when assuming this role\n   *\n   * If the configured and provided external IDs do not match, the\n   * AssumeRole operation will fail.\n   *\n   * @deprecated see `externalIds`\n   *\n   * @default No external ID required\n   */\n  readonly externalId?: string;\n\n  /**\n   * List of IDs that the role assumer needs to provide one of when assuming this role\n   *\n   * If the configured and provided external IDs do not match, the\n   * AssumeRole operation will fail.\n   *\n   * @default No external ID required\n   */\n  readonly externalIds?: string[];\n\n  /**\n   * A list of managed policies associated with this role.\n   *\n   * You can add managed policies later using\n   * `addManagedPolicy(ManagedPolicy.fromAwsManagedPolicyName(policyName))`.\n   *\n   * @default - No managed policies.\n   */\n  readonly managedPolicies?: IManagedPolicy[];\n\n  /**\n   * A list of named policies to inline into this role. These policies will be\n   * created with the role, whereas those added by ``addToPolicy`` are added\n   * using a separate CloudFormation resource (allowing a way around circular\n   * dependencies that could otherwise be introduced).\n   *\n   * @default - No policy is inlined in the Role resource.\n   */\n  readonly inlinePolicies?: { [name: string]: PolicyDocument };\n\n  /**\n   * The path associated with this role. For information about IAM paths, see\n   * Friendly Names and Paths in IAM User Guide.\n   *\n   * @default /\n   */\n  readonly path?: string;\n\n  /**\n   * AWS supports permissions boundaries for IAM entities (users or roles).\n   * A permissions boundary is an advanced feature for using a managed policy\n   * to set the maximum permissions that an identity-based policy can grant to\n   * an IAM entity. An entity's permissions boundary allows it to perform only\n   * the actions that are allowed by both its identity-based policies and its\n   * permissions boundaries.\n   *\n   * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html#cfn-iam-role-permissionsboundary\n   * @link https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html\n   *\n   * @default - No permissions boundary.\n   */\n  readonly permissionsBoundary?: IManagedPolicy;\n\n  /**\n   * A name for the IAM role. For valid values, see the RoleName parameter for\n   * the CreateRole action in the IAM API Reference.\n   *\n   * IMPORTANT: If you specify a name, you cannot perform updates that require\n   * replacement of this resource. You can perform updates that require no or\n   * some interruption. If you must replace the resource, specify a new name.\n   *\n   * Use [Terraform Resource Meta Arguments](https://developer.hashicorp.com/terraform/language/resources/syntax#meta-arguments)\n   * to control lifecycle when replacing the role.\n   *\n   * See [IAM Identifiers](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)\n   * for more information\n   *\n   * @default - If omitted, Refer to `roleNamePrefix`.\n   */\n  readonly roleName?: string;\n\n  /**\n   * Creates a unique name beginning with the specified prefix.\n   * Conflicts with `roleName`.\n   *\n   * IMPORTANT: If you specify a namePrefix, you cannot perform updates that require\n   * replacement of this resource. You can perform updates that require no or\n   * some interruption. If you must replace the resource, specify a new name.\n   *\n   * Use [Terraform Resource Meta Arguments](https://developer.hashicorp.com/terraform/language/resources/syntax#meta-arguments)\n   * to control lifecycle when replacing the role.\n   *\n   * See [IAM Identifiers](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)\n   * for more information\n   *\n   * @default - If omitted, ET will assign a random, unique name prefixed by GridUUID.\n   */\n  readonly roleNamePrefix?: string;\n\n  /**\n   * The maximum session duration in seconds that you want to set for the specified role.\n   * This setting can have a value from 1 hour (3600sec) to 12 (43200sec) hours.\n   *\n   * Anyone who assumes the role from the AWS CLI or API can use the\n   * DurationSeconds API parameter or the duration-seconds CLI parameter to\n   * request a longer session. The MaxSessionDuration setting determines the\n   * maximum duration that can be requested using the DurationSeconds\n   * parameter.\n   *\n   * If users don't specify a value for the DurationSeconds parameter, their\n   * security credentials are valid for one hour by default. This applies when\n   * you use the AssumeRole* API operations or the assume-role* CLI operations\n   * but does not apply when you use those operations to create a console URL.\n   *\n   * @link https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html\n   *\n   * @default Duration.hours(1)\n   */\n  readonly maxSessionDuration?: Duration;\n\n  /**\n   * A description of the role. It can be up to 1000 characters long.\n   *\n   * @default - No description.\n   */\n  readonly description?: string;\n\n  /**\n   * Whether to force detaching any policies the role has before destroying it\n   * If policies are attached to the role via the `aws_iam_policy_attachment`\n   * resource and you are modifying the role `name` or `path`, this must be\n   * set to `true` and applied before attempting the operation otherwise you\n   * will encounter a `DeleteConflict` error.\n   *\n   * The `aws_iam_role_policy_attachment` resource (recommended) does not\n   * have this requirement.\n   *\n   * NOTE: The `iam.Policy` uses `aws_iam_role_policy_attachment` under\n   * the hood and this should not be a concern.\n   *\n   * @default - false\n   */\n  readonly forceDetachPolicies?: boolean;\n}\n\n/**\n * Options allowing customizing the behavior of `Role.fromRoleArn`.\n */\nexport interface FromRoleArnOptions {\n  /**\n   * Whether the imported role can be modified by attaching policy resources to it.\n   *\n   * @default true\n   */\n  readonly mutable?: boolean;\n\n  /**\n   * For immutable roles: add grants to resources instead of dropping them\n   *\n   * If this is `false` or not specified, grant permissions added to this role are ignored.\n   * It is your own responsibility to make sure the role has the required permissions.\n   *\n   * If this is `true`, any grant permissions will be added to the resource instead.\n   *\n   * @default false\n   */\n  readonly addGrantsToResources?: boolean;\n\n  /**\n   * Any policies created by this role will use this value as their ID, if specified.\n   * Specify this if importing the same role in multiple stacks, and granting it\n   * different permissions in at least two stacks. If this is not specified\n   * (or if the same name is specified in more than one stack),\n   * a Terraform issue will result in the policy created in whichever stack\n   * is deployed last overwriting the policies created by the others.\n   *\n   * @default 'Policy'\n   */\n  readonly defaultPolicyName?: string;\n}\n\n// TODO: support for pre-created roles?\n// ref: https://github.com/aws/aws-cdk/blob/v2.143.0/packages/aws-cdk-lib/aws-iam/lib/role.ts#L186\n// NOTE: in TerraConstruct pre-created roles are passed in through the Grid, so this seems not needed.\n\n/**\n * Options allowing customizing the behavior of `Role.fromRoleName`.\n */\nexport interface FromRoleNameOptions extends FromRoleArnOptions {}\n\n/**\n * IAM Role\n *\n * Defines an IAM role. The role is created with an assume policy document associated with\n * the specified AWS service principal defined in `serviceAssumeRole`.\n */\nexport class Role extends AwsConstructBase implements IRole {\n  /**\n   * Import an external role by ARN.\n   *\n   * If the imported Role ARN is a Token (such as a\n   * `CfnParameter.valueAsString` or a `Fn.importValue()`) *and* the referenced\n   * role has a `path` (like `arn:...:role/AdminRoles/Alice`), the\n   * `roleName` property will not resolve to the correct value. Instead it\n   * will resolve to the first path component. We unfortunately cannot express\n   * the correct calculation of the full path name as a CloudFormation\n   * expression. In this scenario the Role ARN should be supplied without the\n   * `path` in order to resolve the correct role resource.\n   *\n   * @param scope construct scope\n   * @param id construct id\n   * @param roleArn the ARN of the role to import\n   * @param options allow customizing the behavior of the returned role\n   */\n  public static fromRoleArn(\n    scope: Construct,\n    id: string,\n    roleArn: string,\n    options: FromRoleArnOptions = {},\n  ): IRole {\n    const scopeStack = AwsStack.ofAwsConstruct(scope);\n    const parsedArn = scopeStack.splitArn(\n      roleArn,\n      ArnFormat.SLASH_RESOURCE_NAME,\n    );\n    const resourceName = parsedArn.resourceName!;\n    const roleAccount = parsedArn.account;\n    // service roles have an ARN like 'arn:aws:iam::<account>:role/service-role/<roleName>'\n    // or 'arn:aws:iam::<account>:role/service-role/servicename.amazonaws.com/service-role/<roleName>'\n    // we want to support these as well, so we just use the element after the last slash as role name\n    const roleName = resourceName.split(\"/\").pop()!;\n\n    // if (getCustomizeRolesConfig(scope).enabled) {\n    //   return new PrecreatedRole(scope, id, {\n    //     rolePath: `${scope.node.path}/${id}`,\n    //     role: new ImportedRole(scope, `Import${id}`, {\n    //       account: roleAccount,\n    //       roleArn,\n    //       roleName,\n    //       ...options,\n    //     }),\n    //   });\n    // }\n\n    if (\n      options.addGrantsToResources !== undefined &&\n      options.mutable !== false\n    ) {\n      throw new Error(\n        \"'addGrantsToResources' can only be passed if 'mutable: false'\",\n      );\n    }\n\n    const roleArnAndScopeStackAccountComparison = tokenCompareStrings(\n      roleAccount ?? \"\",\n      scopeStack.account,\n    );\n    const equalOrAnyUnresolved =\n      roleArnAndScopeStackAccountComparison === TokenComparison.SAME ||\n      roleArnAndScopeStackAccountComparison ===\n        TokenComparison.BOTH_UNRESOLVED ||\n      roleArnAndScopeStackAccountComparison === TokenComparison.ONE_UNRESOLVED;\n\n    // if we are returning an immutable role then the 'importedRole' is just a throwaway construct\n    // so give it a different id\n    const mutableRoleId =\n      options.mutable !== false && equalOrAnyUnresolved\n        ? id\n        : `MutableRole${id}`;\n    const importedRole = new ImportedRole(scope, mutableRoleId, {\n      roleArn,\n      roleName,\n      account: roleAccount,\n      ...options,\n    });\n\n    // we only return an immutable Role if both accounts were explicitly provided, and different\n    return options.mutable !== false && equalOrAnyUnresolved\n      ? importedRole\n      : new ImmutableRole(\n          scope,\n          id,\n          importedRole,\n          options.addGrantsToResources ?? false,\n        );\n  }\n\n  /**\n   * Return whether the given object is a Role\n   */\n  public static isRole(x: any): x is Role {\n    return x !== null && typeof x === \"object\" && IAM_ROLE_SYMBOL in x;\n  }\n\n  /**\n   * Import an external role by name.\n   *\n   * The imported role is assumed to exist in the same account as the account\n   * the scope's containing Stack is being deployed to.\n\n   * @param scope construct scope\n   * @param id construct id\n   * @param roleName the name of the role to import\n   * @param options allow customizing the behavior of the returned role\n   */\n  public static fromRoleName(\n    scope: Construct,\n    id: string,\n    roleName: string,\n    options: FromRoleNameOptions = {},\n  ) {\n    return Role.fromRoleArn(\n      scope,\n      id,\n      AwsStack.ofAwsConstruct(scope).formatArn({\n        region: \"\",\n        service: \"iam\",\n        resource: \"role\",\n        resourceName: roleName,\n      }),\n      options,\n    );\n  }\n\n  // TODO: Support custom role creation\n  // https://github.com/aws/aws-cdk/blob/v2.143.0/packages/aws-cdk-lib/aws-iam/lib/role.ts#L355\n\n  public readonly grantPrincipal: IPrincipal = this;\n  public readonly principalAccount: string | undefined = this.env.account;\n\n  public readonly assumeRoleAction: string = \"sts:AssumeRole\";\n\n  /**\n   * The assume role policy document associated with this role.\n   */\n  public readonly assumeRolePolicy?: PolicyDocument;\n\n  /**\n   * Returns the ARN of this role.\n   */\n  public readonly roleArn: string;\n\n  /**\n   * Returns the name of the role.\n   */\n  public readonly roleName: string;\n\n  /**\n   * Returns the role.\n   */\n  public readonly policyFragment: PrincipalPolicyFragment;\n\n  /**\n   * Returns the permissions boundary attached to this role\n   */\n  public readonly permissionsBoundary?: IManagedPolicy;\n\n  /** Strongly typed Outputs */\n  public get roleOutputs(): RoleOutputs {\n    return {\n      arn: this.roleArn,\n      name: this.roleName,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.roleOutputs;\n  }\n  /**\n   * Direct access to the underlying Terraform resource.\n   */\n  public readonly resource: iamRole.IamRole;\n  private defaultPolicy?: Policy;\n  private readonly managedPolicies: IManagedPolicy[] = [];\n  private readonly attachedPolicies = new AttachedPolicies();\n  private readonly inlinePolicies: { [name: string]: PolicyDocument };\n  // private readonly dependables = new Map<PolicyStatement, DependencyGroup>();\n  private immutableRole?: IRole;\n  // private _didSplit = false;\n  private readonly _roleId: string;\n\n  constructor(scope: Construct, id: string, props: RoleProps) {\n    super(scope, id, props);\n\n    if (\n      props.roleName &&\n      !Token.isUnresolved(props.roleName) &&\n      !/^[\\w+=,.@-]{1,64}$/.test(props.roleName)\n    ) {\n      throw new Error(\n        \"Invalid roleName. The name must be a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-. Length must be between 1 and 64 characters.\",\n      );\n    }\n\n    if (props.roleName && props.roleNamePrefix) {\n      throw new Error(\n        \"Cannot specify both 'roleName' and 'roleNamePrefix'. Use only one.\",\n      );\n    }\n\n    const externalIds = props.externalIds || [];\n    if (props.externalId) {\n      externalIds.push(props.externalId);\n    }\n\n    this.assumeRolePolicy = createAssumeRolePolicy(\n      this,\n      \"AssumeRolePolicy\",\n      props.assumedBy,\n      externalIds,\n    );\n    this.managedPolicies.push(...(props.managedPolicies || []));\n    this.inlinePolicies = props.inlinePolicies || {};\n    this.permissionsBoundary = props.permissionsBoundary;\n    const maxSessionDuration =\n      props.maxSessionDuration && props.maxSessionDuration.toSeconds();\n    validateMaxSessionDuration(maxSessionDuration);\n    const description =\n      props.description && props.description?.length > 0\n        ? props.description\n        : undefined;\n\n    if (description && description.length > 1000) {\n      throw new Error(\n        \"Role description must be no longer than 1000 characters.\",\n      );\n    }\n\n    validateRolePath(props.path);\n\n    // pre-created role snipped\n    // https://github.com/aws/aws-cdk/blob/v2.143.0/packages/aws-cdk-lib/aws-iam/lib/role.ts#L439\n\n    const namePrefix = this.stack.uniqueResourceNamePrefix(this, {\n      prefix: props.roleNamePrefix ?? this.gridUUID + \"-\",\n      allowedSpecialCharacters: \"_+=,.@-\",\n      maxLength: 64,\n    });\n\n    this.resource = new iamRole.IamRole(this, \"Resource\", {\n      ...props, // copy over Terraform Meta Arguments from ConstructProps\n      assumeRolePolicy: this.assumeRolePolicy.json,\n      managedPolicyArns: UniqueStringSet.from(() =>\n        this.managedPolicies.map((p) => p.managedPolicyArn),\n      ),\n      inlinePolicy: _flatten(this.inlinePolicies),\n      path: props.path,\n      permissionsBoundary: this.permissionsBoundary\n        ? this.permissionsBoundary.managedPolicyArn\n        : undefined,\n      name: props.roleName,\n      namePrefix: !props.roleName ? namePrefix : undefined,\n      maxSessionDuration,\n      description,\n      forceDetachPolicies: props.forceDetachPolicies,\n    });\n\n    // Stable and unique string identifying the role.\n    this._roleId = this.resource.uniqueId;\n\n    // TODO: Need to handle cross env ARN refs?\n    // CDK: https://github.com/aws/aws-cdk/blob/v2.143.0/packages/aws-cdk-lib/core/lib/resource.ts#L288\n    this.roleArn = this.resource.arn;\n    // TODO: Need to handle cross env Name refs?\n    // CDK: https://github.com/aws/aws-cdk/blob/v2.143.0/packages/aws-cdk-lib/core/lib/resource.ts#L254\n    this.roleName = this.resource.name;\n\n    // TODO: Re-add policy splitting?\n    // Aspects.of(this).add({\n    //   visit: (c) => {\n    //     if (c === this) {\n    //       this.splitLargePolicy();\n    //     }\n    //   },\n    // });\n\n    this.policyFragment = new ArnPrincipal(this.roleArn).policyFragment;\n\n    function _flatten(policies?: { [name: string]: PolicyDocument }) {\n      if (policies == null || Object.keys(policies).length === 0) {\n        return undefined;\n      }\n      const result = new Array<iamRole.IamRoleInlinePolicy>();\n      for (const policyName of Object.keys(policies)) {\n        const policyDocument = policies[policyName];\n        result.push({\n          name: policyName,\n          policy: policyDocument.json,\n        });\n      }\n      return result;\n    }\n\n    this.node.addValidation({ validate: () => this.validateRole() });\n  }\n\n  /**\n   * Adds a permission to the role's default policy document.\n   * If there is no default policy attached to this role, it will be created.\n   * @param statement The permission statement to add to the policy document\n   */\n  public addToPrincipalPolicy(\n    statement: PolicyStatement,\n  ): AddToPrincipalPolicyResult {\n    if (!this.defaultPolicy) {\n      this.defaultPolicy = new Policy(this, \"DefaultPolicy\");\n      this.attachInlinePolicy(this.defaultPolicy);\n    }\n    this.defaultPolicy.addStatements(statement);\n\n    // // We might split this statement off into a different policy, so we'll need to\n    // // late-bind the dependable.\n    // const policyDependable = new DependencyGroup();\n    // this.dependables.set(statement, policyDependable);\n\n    return { statementAdded: true, policyDependable: this };\n  }\n\n  public addToPolicy(statement: PolicyStatement): boolean {\n    return this.addToPrincipalPolicy(statement).statementAdded;\n  }\n\n  /**\n   * Attaches a managed policy to this role.\n   *\n   * NOTE: Using this method will force the role to take over\n   * exclusive management of the role's ManagedPolicy attachments\n   * These arguments are incompatible with other ways of managing\n   * a role's such as attaching the policy to the role through its\n   * `policy.attachToRole(role)` method.\n   *\n   * If you attempt to manage a role's policies by multiple means,\n   * you will get resource cycling and/or errors.\n   *\n   * ```typescript\n   * const policy1 = new iam.ManagedPolicy(this, 'Policy', {\n   *   managedPolicyName: 'MyPolicy1',\n   *   description: 'A description of the policy',\n   * });\n   * const policy2 = new iam.ManagedPolicy(this, 'Policy', {\n   *   managedPolicyName: 'MyPolicy2',\n   *   description: 'A description of the policy',\n   * });\n   *\n   * const role = new iam.Role(this, 'Role', {\n   *  assumedBy: new iam.ServicePrincipal('sns.amazonaws.com'),\n   * });\n   * // role becomes the manager of all attached policies\n   * role.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName('SecurityAudit'));\n   * role.addManagedPolicy(policy1);\n   *\n   * // this introduces resource cycling\n   * // DON'T DO THIS\n   * policy2.attachToRole(role);\n   *\n   * // DO THIS INSTEAD\n   * role.addManagedPolicy(policy2);\n   * ```\n   * @param policy The the managed policy to attach.\n   */\n  public addManagedPolicy(policy: IManagedPolicy) {\n    if (\n      this.managedPolicies.some(\n        (mp) => mp.managedPolicyArn === policy.managedPolicyArn,\n      )\n    ) {\n      return;\n    }\n    this.managedPolicies.push(policy);\n  }\n\n  /**\n   * Attaches a policy to this role.\n   *\n   * NOTE: Using this method will force the role to take over\n   * exclusive management of the role's inline Policy attachments\n   * These arguments are incompatible with other ways of managing\n   * a role's such as attaching a policy to the role.\n   * If you attempt to manage a role's policies by multiple means,\n   * you will get resource cycling and/or errors.\n   *\n   * @param policy The policy to attach\n   */\n  public attachInlinePolicy(policy: Policy) {\n    this.attachedPolicies.attach(policy);\n    policy.attachToRole(this);\n  }\n\n  /**\n   * Grant the actions defined in actions to the identity Principal on this resource.\n   */\n  public grant(grantee: IPrincipal, ...actions: string[]) {\n    return Grant.addToPrincipal({\n      grantee,\n      actions,\n      resourceArns: [this.roleArn],\n      scope: this,\n    });\n  }\n\n  /**\n   * Grant permissions to the given principal to pass this role.\n   */\n  public grantPassRole(identity: IPrincipal) {\n    return this.grant(identity, \"iam:PassRole\");\n  }\n\n  /**\n   * Grant permissions to the given principal to assume this role.\n   */\n  public grantAssumeRole(identity: IPrincipal) {\n    // Service and account principals must use assumeRolePolicy\n    if (\n      identity instanceof ServicePrincipal ||\n      identity instanceof AccountPrincipal\n    ) {\n      throw new Error(\n        \"Cannot use a service or account principal with grantAssumeRole, use assumeRolePolicy instead.\",\n      );\n    }\n    return this.grant(identity, \"sts:AssumeRole\");\n  }\n\n  /**\n   * Returns the stable and unique string identifying the role. For example,\n   * AIDAJQABLZS4A3QDU576Q.\n   *\n   * @attribute\n   */\n  public get roleId(): string {\n    return this._roleId;\n  }\n\n  /**\n   * Return a copy of this Role object whose Policies will not be updated\n   *\n   * Use the object returned by this method if you want this Role to be used by\n   * a construct without it automatically updating the Role's Policies.\n   *\n   * If you do, you are responsible for adding the correct statements to the\n   * Role's policies yourself.\n   */\n  public withoutPolicyUpdates(\n    options: WithoutPolicyUpdatesOptions = {},\n  ): IRole {\n    if (!this.immutableRole) {\n      this.immutableRole = new ImmutableRole(\n        this.node.scope as Construct,\n        `ImmutableRole${this.node.id}`,\n        this,\n        options.addGrantsToResources ?? false,\n      );\n    }\n\n    return this.immutableRole;\n  }\n\n  private validateRole(): string[] {\n    const errors = new Array<string>();\n    errors.push(...(this.assumeRolePolicy?.validateForResourcePolicy() ?? []));\n    for (const policy of Object.values(this.inlinePolicies)) {\n      errors.push(...policy.validateForIdentityPolicy());\n    }\n\n    return errors;\n  }\n\n  // /**\n  //  * Split large inline policies into managed policies\n  //  *\n  //  * This gets around the 10k bytes limit on role policies.\n  //  */\n  // private splitLargePolicy() {\n  //   if (!this.defaultPolicy || this._didSplit) {\n  //     return;\n  //   }\n  //   this._didSplit = true;\n\n  //   const self = this;\n  //   const originalDoc = this.defaultPolicy.document;\n\n  //   const splitOffDocs = originalDoc._splitDocument(\n  //     this,\n  //     MAX_INLINE_SIZE,\n  //     MAX_MANAGEDPOL_SIZE,\n  //   );\n  //   // Includes the \"current\" document\n\n  //   const mpCount = this.managedPolicies.length + (splitOffDocs.size - 1);\n  //   if (mpCount > 20) {\n  //     Annotations.of(this).addWarningV2(\n  //       \"@aws-cdk/aws-iam:rolePolicyTooLarge\",\n  //       `Policy too large: ${mpCount} exceeds the maximum of 20 managed policies attached to a Role`,\n  //     );\n  //   } else if (mpCount > 10) {\n  //     Annotations.of(this).addWarningV2(\n  //       \"@aws-cdk/aws-iam:rolePolicyLarge\",\n  //       `Policy large: ${mpCount} exceeds 10 managed policies attached to a Role, this requires a quota increase`,\n  //     );\n  //   }\n\n  //   // Create the managed policies and fix up the dependencies\n  //   markDeclaringConstruct(originalDoc, this.defaultPolicy);\n\n  //   let i = 1;\n  //   for (const newDoc of splitOffDocs.keys()) {\n  //     if (newDoc === originalDoc) {\n  //       continue;\n  //     }\n\n  //     const mp = new AwsManagedPolicy(this, `OverflowPolicy${i++}`, {\n  //       description: `Part of the policies for ${this.node.path}`,\n  //       document: newDoc,\n  //       roles: [this],\n  //     });\n  //     markDeclaringConstruct(newDoc, mp);\n  //   }\n\n  //   /**\n  //    * Update the Dependables for the statements in the given PolicyDocument to point to the actual declaring construct\n  //    */\n  //   function markDeclaringConstruct(\n  //     doc: PolicyDocument,\n  //     declaringConstruct: IConstruct,\n  //   ) {\n  //     for (const original of splitOffDocs.get(doc) ?? []) {\n  //       self.dependables.get(original)?.add(declaringConstruct);\n  //     }\n  //   }\n  // }\n}\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface RoleOutputs {\n  readonly arn: string;\n  readonly name: string;\n}\n\n/**\n * A Role object\n */\nexport interface IRole extends IIdentity {\n  /**\n   * strongly typed roleOutputs\n   *\n   * @attribute\n   */\n  readonly roleOutputs: RoleOutputs;\n  /**\n   * Returns the ARN of this role.\n   *\n   * @attribute\n   */\n  readonly roleArn: string;\n\n  /**\n   * Returns the name of this role.\n   *\n   * @attribute\n   */\n  readonly roleName: string;\n\n  /**\n   * Grant the actions defined in actions to the identity Principal on this resource.\n   */\n  grant(grantee: IPrincipal, ...actions: string[]): Grant;\n\n  /**\n   * Grant permissions to the given principal to pass this role.\n   */\n  grantPassRole(grantee: IPrincipal): Grant;\n\n  /**\n   * Grant permissions to the given principal to assume this role.\n   */\n  grantAssumeRole(grantee: IPrincipal): Grant;\n}\n\nfunction createAssumeRolePolicy(\n  scope: Construct,\n  id: string,\n  principal: IPrincipal,\n  externalIds: string[],\n) {\n  const actualDoc = new PolicyDocument(scope, id);\n\n  // If requested, add externalIds to every statement added to this doc\n  const addDoc =\n    externalIds.length === 0\n      ? actualDoc\n      : new MutatingPolicyDocumentAdapter(actualDoc, (statement) => {\n          statement.addCondition({\n            test: \"StringEquals\",\n            variable: \"sts:ExternalId\",\n            values: externalIds,\n          });\n          return statement;\n        });\n\n  defaultAddPrincipalToAssumeRole(principal, addDoc);\n\n  return actualDoc;\n}\n\nfunction validateRolePath(path?: string) {\n  if (path === undefined || Token.isUnresolved(path)) {\n    return;\n  }\n\n  const validRolePath = /^(\\/|\\/[\\u0021-\\u007F]+\\/)$/;\n\n  if (path.length == 0 || path.length > 512) {\n    throw new Error(\n      `Role path must be between 1 and 512 characters. The provided role path is ${path.length} characters.`,\n    );\n  } else if (!validRolePath.test(path)) {\n    throw new Error(\n      \"Role path must be either a slash or valid characters (alphanumerics and symbols) surrounded by slashes. \" +\n        `Valid characters are unicode characters in [\\\\u0021-\\\\u007F]. However, ${path} is provided.`,\n    );\n  }\n}\n\nfunction validateMaxSessionDuration(duration?: number) {\n  if (duration === undefined) {\n    return;\n  }\n\n  if (duration < 3600 || duration > 43200) {\n    throw new Error(\n      `maxSessionDuration is set to ${duration}, but must be >= 3600sec (1hr) and <= 43200sec (12hrs)`,\n    );\n  }\n}\n\n/**\n * Options for the `withoutPolicyUpdates()` modifier of a Role\n */\nexport interface WithoutPolicyUpdatesOptions {\n  /**\n   * Add grants to resources instead of dropping them\n   *\n   * If this is `false` or not specified, grant permissions added to this role are ignored.\n   * It is your own responsibility to make sure the role has the required permissions.\n   *\n   * If this is `true`, any grant permissions will be added to the resource instead.\n   *\n   * @default false\n   */\n  readonly addGrantsToResources?: boolean;\n}\n\nObject.defineProperty(Role.prototype, IAM_ROLE_SYMBOL, {\n  value: true,\n  enumerable: false,\n  writable: false,\n});\n"]}

package/lib/aws/iam/saml-provider.d.ts

@@ -0,0 +1,79 @@
+import { iamSamlProvider } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { IAwsConstruct, AwsConstructBase, AwsConstructProps } from "../";
+export interface SamlProviderOutputs {
+    /**
+     * The Amazon Resource Name (ARN) of the SAML provider.
+     * @stability stable
+     */
+    readonly arn: string;
+}
+/**
+ * A SAML provider
+ */
+export interface ISamlProvider extends IAwsConstruct {
+    readonly samlProviderOutputs: SamlProviderOutputs;
+    /**
+     * The Amazon Resource Name (ARN) of the provider
+     *
+     * @attribute
+     */
+    readonly samlProviderArn: string;
+}
+/**
+ * Properties for a SAML provider
+ */
+export interface SamlProviderProps extends AwsConstructProps {
+    /**
+     * The name of the provider to create.
+     *
+     * This parameter allows a string of characters consisting of upper and
+     * lowercase alphanumeric characters with no spaces. You can also include
+     * any of the following characters: _+=,.@-
+     *
+     * Length must be between 1 and 128 characters.
+     *
+     * @default - a unique name based on path within stack
+     */
+    readonly name?: string;
+    /**
+     * An XML document generated by an identity provider (IdP) that supports
+     * SAML 2.0. The document includes the issuer's name, expiration information,
+     * and keys that can be used to validate the SAML authentication response
+     * (assertions) that are received from the IdP. You must generate the metadata
+     * document using the identity management software that is used as your
+     * organization's IdP.
+     */
+    readonly metadataDocument: SamlMetadataDocument;
+}
+/**
+ * A SAML metadata document
+ */
+export declare abstract class SamlMetadataDocument {
+    /**
+     * Create a SAML metadata document from a XML string
+     */
+    static fromXml(xml: string): SamlMetadataDocument;
+    /**
+     * Create a SAML metadata document from a XML file
+     */
+    static fromFile(path: string): SamlMetadataDocument;
+    /**
+     * The XML content of the metadata document
+     */
+    abstract readonly xml: string;
+}
+/**
+ * A SAML provider
+ */
+export declare class SamlProvider extends AwsConstructBase implements ISamlProvider {
+    /**
+     * Import an existing provider
+     */
+    static fromSamlProviderArn(scope: Construct, id: string, samlProviderArn: string): ISamlProvider;
+    readonly samlProviderOutputs: SamlProviderOutputs;
+    get outputs(): Record<string, any>;
+    readonly resource: iamSamlProvider.IamSamlProvider;
+    readonly samlProviderArn: string;
+    constructor(scope: Construct, id: string, props: SamlProviderProps);
+}