terraconstructs 0.0.8

package/lib/aws/iam/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./grant"), exports);
+__exportStar(require("./identity-base"), exports);
+__exportStar(require("./managed-policy"), exports);
+__exportStar(require("./oidc-provider"), exports);
+__exportStar(require("./policy-document-config.generated"), exports);
+__exportStar(require("./policy-document"), exports);
+__exportStar(require("./policy-statement-props.generated"), exports);
+__exportStar(require("./policy-statement"), exports);
+__exportStar(require("./policy"), exports);
+__exportStar(require("./principals"), exports);
+__exportStar(require("./role"), exports);
+__exportStar(require("./saml-provider"), exports);
+__exportStar(require("./unknown-principal"), exports);
+__exportStar(require("./utils"), exports);
+// auto generated by struct-builder
+__exportStar(require("./policy-statement-props.generated"), exports);
+__exportStar(require("./policy-document-config.generated"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXdzL2lhbS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsMENBQXdCO0FBQ3hCLGtEQUFnQztBQUNoQyxtREFBaUM7QUFDakMsa0RBQWdDO0FBQ2hDLHFFQUFtRDtBQUNuRCxvREFBa0M7QUFDbEMscUVBQW1EO0FBQ25ELHFEQUFtQztBQUNuQywyQ0FBeUI7QUFDekIsK0NBQTZCO0FBQzdCLHlDQUF1QjtBQUN2QixrREFBZ0M7QUFDaEMsc0RBQW9DO0FBQ3BDLDBDQUF3QjtBQUV4QixtQ0FBbUM7QUFDbkMscUVBQW1EO0FBQ25ELHFFQUFtRCIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2dyYW50XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9pZGVudGl0eS1iYXNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9tYW5hZ2VkLXBvbGljeVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vb2lkYy1wcm92aWRlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vcG9saWN5LWRvY3VtZW50LWNvbmZpZy5nZW5lcmF0ZWRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3BvbGljeS1kb2N1bWVudFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vcG9saWN5LXN0YXRlbWVudC1wcm9wcy5nZW5lcmF0ZWRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3BvbGljeS1zdGF0ZW1lbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3BvbGljeVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vcHJpbmNpcGFsc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vcm9sZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vc2FtbC1wcm92aWRlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdW5rbm93bi1wcmluY2lwYWxcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzXCI7XG5cbi8vIGF1dG8gZ2VuZXJhdGVkIGJ5IHN0cnVjdC1idWlsZGVyXG5leHBvcnQgKiBmcm9tIFwiLi9wb2xpY3ktc3RhdGVtZW50LXByb3BzLmdlbmVyYXRlZFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vcG9saWN5LWRvY3VtZW50LWNvbmZpZy5nZW5lcmF0ZWRcIjtcbiJdfQ==

package/lib/aws/iam/managed-policy.d.ts

@@ -0,0 +1,227 @@
+import { iamPolicy, dataAwsIamPolicy } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { PolicyDocument } from "./policy-document";
+import { PolicyStatement } from "./policy-statement";
+import { IGrantable, IPrincipal } from "./principals";
+import { IRole } from "./role";
+import { IAwsConstruct, AwsConstructBase, AwsConstructProps } from "../aws-construct";
+/**
+ * Outputs which may be registered for output via the Grid.
+ */
+export interface ManagedPolicyOutputs {
+    readonly arn: string;
+}
+/**
+ * A managed policy
+ */
+export interface IManagedPolicy extends IAwsConstruct {
+    /**
+     * Strongly typed managed policy outputs
+     *
+     * @attribute
+     */
+    readonly managedPolicyOutputs: ManagedPolicyOutputs;
+    /**
+     * The ARN of the managed policy
+     * @attribute
+     */
+    readonly managedPolicyArn: string;
+    /**
+     * Attaches this policy to a role.
+     *
+     * NOTE: Using this method will conflict with a role that has
+     * exclusive management of the role's policy attachments.
+     *
+     * If you attempt to manage a role's policies by multiple means,
+     * you will get resource cycling and/or errors.
+     */
+    attachToRole(role: IRole): void;
+}
+/**
+ * Properties for defining an IAM managed policy
+ */
+export interface ManagedPolicyProps extends AwsConstructProps {
+    /**
+     * The name of the managed policy. If you specify multiple policies for an entity,
+     * specify unique names. For example, if you specify a list of policies for
+     * an IAM role, each policy must have a unique name.
+     *
+     * Forces new resource
+     *
+     * @default - If omitted, Refer to `managedPolicyNamePrefix`.
+     */
+    readonly managedPolicyName?: string;
+    /**
+     * Creates a unique name beginning with the specified prefix.
+     * Conflicts with `managedPolicyName`.
+     *
+     * The name of the managed policy. If you specify multiple policies for an entity,
+     * specify unique names. For example, if you specify a list of policies for
+     * an IAM role, each policy must have a unique name.
+     *
+     * Forces new resource
+     *
+     * @default - If omitted, ET will assign a random, unique name prefixed by GridUUID.
+     */
+    readonly managedPolicyNamePrefix?: string;
+    /**
+     * A description of the managed policy. Typically used to store information about the
+     * permissions defined in the policy. For example, "Grants access to production DynamoDB tables."
+     * The policy description is immutable. After a value is assigned, it cannot be changed.
+     *
+     * Forces new resource
+     *
+     * @default - Terraform will generate a description
+     */
+    readonly description?: string;
+    /**
+     * The path for the policy. This parameter allows (through its regex pattern) a string of characters
+     * consisting of either a forward slash (/) by itself or a string that must begin and end with forward slashes.
+     * In addition, it can contain any ASCII character from the ! (\u0021) through the DEL character (\u007F),
+     * including most punctuation characters, digits, and upper and lowercased letters.
+     *
+     * For more information about paths, see IAM Identifiers in the IAM User Guide.
+     *
+     * @default - "/"
+     */
+    readonly path?: string;
+    /**
+     * Roles to attach this policy to.
+     * You can also use `attachToRole(role)` to attach this policy to a role.
+     *
+     * @default - No roles.
+     */
+    readonly roles?: IRole[];
+    /**
+     * Initial set of permissions to add to this policy document.
+     * You can also use `addPermission(statement)` to add permissions later.
+     *
+     * @default - No statements.
+     */
+    readonly statements?: PolicyStatement[];
+    /**
+     * Initial PolicyDocument to use for this ManagedPolicy. If omited, any
+     * `PolicyStatement` provided in the `statements` property will be applied
+     * against the empty default `PolicyDocument`.
+     *
+     * @default - An empty policy.
+     */
+    readonly document?: PolicyDocument;
+}
+/**
+ * Attributes to reference ManagedPolicy for plan time failures and strict external dependencies.
+ */
+export interface ManagedPolicyAttributes extends dataAwsIamPolicy.DataAwsIamPolicyConfig {
+}
+/**
+ * Managed policy base
+ */
+declare abstract class ManagedPolicyBase extends AwsConstructBase implements IManagedPolicy {
+    /**
+     * Returns the ARN of this managed policy.
+     *
+     * @attribute
+     */
+    abstract get managedPolicyArn(): string;
+    get managedPolicyOutputs(): ManagedPolicyOutputs;
+    get outputs(): Record<string, any>;
+    private readonly roles;
+    constructor(scope: Construct, id: string, props?: ManagedPolicyProps);
+    attachToRole(role: IRole): void;
+    /**
+     * Adds resource to the terraform JSON output.
+     *
+     * called by TerraformStack.prepareStack()
+     */
+    toTerraform(): any;
+}
+/**
+ * Managed policy
+ */
+export declare class ManagedPolicy extends ManagedPolicyBase implements IManagedPolicy, IGrantable {
+    /**
+     * Import a customer managed policy from the managedPolicyName.
+     *
+     * For this managed policy, you only need to know the name to be able to use it.
+     *
+     */
+    static fromManagedPolicyName(scope: Construct, id: string, managedPolicyName: string): IManagedPolicy;
+    /**
+     * Import an external managed policy by ARN.
+     *
+     * For this managed policy, you only need to know the ARN to be able to use it.
+     * This can be useful if you got the ARN from the Grid.
+     *
+     * If the imported Managed Policy ARN is a Token (such as a
+     * `dataAwsSsmParameter.value` *and* the referenced
+     * managed policy has a `path` (like `arn:...:policy/AdminPolicy/AdminAllow`), the
+     * `managedPolicyName` property will not resolve to the correct value. Instead it
+     * will resolve to the first path component.
+     * In this scenario the Managed Policy ARN should be supplied without the
+     * `path` in order to resolve the correct managed policy resource.
+     *
+     * @param scope construct scope
+     * @param id construct id
+     * @param managedPolicyArn the ARN of the managed policy to import
+     */
+    static fromManagedPolicyArn(scope: Construct, id: string, // TODO: remove this, use managedPolicyArn as id?
+    managedPolicyArn: string): IManagedPolicy;
+    /**
+     * Import a managed policy from one of the policies that AWS manages.
+     *
+     * For this managed policy, you only need to know the name and scope
+     * to be able to use it.
+     *
+     * Some managed policy names start with "service-role/", some start with
+     * "job-function/", and some don't start with anything. Include the
+     * prefix when constructing this object.
+     */
+    static fromAwsManagedPolicyName(scope: Construct, id: string, //TODO: use managedPolicyName as id instead?
+    managedPolicyName: string): IManagedPolicy;
+    /**
+     * Reference a ManagedPolicy for plan time failures and external dependencies.
+     */
+    static fromPolicyAttributes(parentScope: Construct, parentId: string, attr: ManagedPolicyAttributes): IManagedPolicy;
+    /**
+     * Returns the ARN of this managed policy.
+     *
+     * @attribute
+     */
+    get managedPolicyArn(): string;
+    /**
+     * The policy document.
+     */
+    readonly document: PolicyDocument;
+    /**
+     * The name of this policy.
+     *
+     * @attribute
+     */
+    get managedPolicyName(): string;
+    /**
+     * The description of this policy.
+     *
+     * @attribute
+     */
+    readonly description?: string;
+    /**
+     * The path of this policy.
+     *
+     * @attribute
+     */
+    readonly path: string;
+    readonly grantPrincipal: IPrincipal;
+    /**
+     * Direct access to the underlying Terraform resource.
+     *
+     * Use to define dependencies on this ManagedPolicy.
+     */
+    resource: iamPolicy.IamPolicy;
+    constructor(scope: Construct, id: string, props?: ManagedPolicyProps);
+    /**
+     * Adds a statement to the policy document.
+     */
+    addStatements(...statement: PolicyStatement[]): void;
+    private validateManagedPolicy;
+}
+export {};

package/lib/aws/iam/managed-policy.js

@@ -0,0 +1,237 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManagedPolicy = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const policy_document_1 = require("./policy-document");
+const arn_1 = require("../arn");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+/**
+ * Managed policy base
+ */
+class ManagedPolicyBase extends aws_construct_1.AwsConstructBase {
+    get managedPolicyOutputs() {
+        return { arn: this.managedPolicyArn };
+    }
+    get outputs() {
+        return this.managedPolicyOutputs;
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.roles = new Array();
+    }
+    attachToRole(role) {
+        if (this.roles.find((r) => r.roleArn === role.roleArn)) {
+            return;
+        }
+        this.roles.push(role);
+    }
+    /**
+     * Adds resource to the terraform JSON output.
+     *
+     * called by TerraformStack.prepareStack()
+     */
+    toTerraform() {
+        // add iamRolePolicy resource for each referenced role
+        for (let i = 0; i < this.roles.length; i++) {
+            const id = `Roles${i}`;
+            // TODO: Ideally we should have used IResolvable.resolve and use the IResolveContext.preparing flag
+            // ref: https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-iam/lib/policy-document.ts#L48
+            if (this.node.tryFindChild(id))
+                continue; // ignore if already generated
+            new provider_aws_1.iamRolePolicyAttachment.IamRolePolicyAttachment(this, id, {
+                policyArn: this.managedPolicyArn,
+                role: this.roles[i].roleName,
+            });
+        }
+        return {};
+    }
+}
+/**
+ * Managed policy
+ */
+class ManagedPolicy extends ManagedPolicyBase {
+    /**
+     * Import a customer managed policy from the managedPolicyName.
+     *
+     * For this managed policy, you only need to know the name to be able to use it.
+     *
+     */
+    static fromManagedPolicyName(scope, id, managedPolicyName) {
+        class Import extends ManagedPolicyBase {
+            constructor() {
+                super(...arguments);
+                this.managedPolicyArn = aws_stack_1.AwsStack.ofAwsConstruct(scope).formatArn({
+                    service: "iam",
+                    region: "", // no region for managed policy
+                    account: this.env.account,
+                    resource: "policy",
+                    resourceName: managedPolicyName,
+                });
+            }
+        }
+        return new Import(scope, id, {});
+    }
+    /**
+     * Import an external managed policy by ARN.
+     *
+     * For this managed policy, you only need to know the ARN to be able to use it.
+     * This can be useful if you got the ARN from the Grid.
+     *
+     * If the imported Managed Policy ARN is a Token (such as a
+     * `dataAwsSsmParameter.value` *and* the referenced
+     * managed policy has a `path` (like `arn:...:policy/AdminPolicy/AdminAllow`), the
+     * `managedPolicyName` property will not resolve to the correct value. Instead it
+     * will resolve to the first path component.
+     * In this scenario the Managed Policy ARN should be supplied without the
+     * `path` in order to resolve the correct managed policy resource.
+     *
+     * @param scope construct scope
+     * @param id construct id
+     * @param managedPolicyArn the ARN of the managed policy to import
+     */
+    static fromManagedPolicyArn(scope, id, // TODO: remove this, use managedPolicyArn as id?
+    managedPolicyArn) {
+        // TODO: Check scope if child already exist and return that?
+        class Import extends ManagedPolicyBase {
+            constructor() {
+                super(...arguments);
+                this.managedPolicyArn = managedPolicyArn;
+            }
+        }
+        return new Import(scope, id);
+    }
+    /**
+     * Import a managed policy from one of the policies that AWS manages.
+     *
+     * For this managed policy, you only need to know the name and scope
+     * to be able to use it.
+     *
+     * Some managed policy names start with "service-role/", some start with
+     * "job-function/", and some don't start with anything. Include the
+     * prefix when constructing this object.
+     */
+    static fromAwsManagedPolicyName(scope, id, //TODO: use managedPolicyName as id instead?
+    managedPolicyName) {
+        class AwsManagedPolicy extends ManagedPolicyBase {
+            constructor() {
+                super(...arguments);
+                this.managedPolicyArn = arn_1.Arn.format({
+                    partition: this.env.partition,
+                    service: "iam",
+                    region: "", // no region for managed policy
+                    account: "aws", // the account for a managed policy is 'aws'
+                    resource: "policy",
+                    resourceName: managedPolicyName,
+                });
+            }
+        }
+        return new AwsManagedPolicy(scope, id);
+    }
+    /**
+     * Reference a ManagedPolicy for plan time failures and external dependencies.
+     */
+    static fromPolicyAttributes(parentScope, parentId, attr) {
+        class Import extends ManagedPolicyBase {
+            constructor(scope, id) {
+                super(scope, id, attr);
+                this.resource = new provider_aws_1.dataAwsIamPolicy.DataAwsIamPolicy(this, "Resource", attr);
+                this.managedPolicyArn = this.resource.arn;
+            }
+        }
+        return new Import(parentScope, parentId);
+    }
+    /**
+     * Returns the ARN of this managed policy.
+     *
+     * @attribute
+     */
+    get managedPolicyArn() {
+        return this.resource.arn;
+    }
+    /**
+     * The name of this policy.
+     *
+     * @attribute
+     */
+    get managedPolicyName() {
+        return this.resource.name;
+    }
+    // TODO: Add support for pre-created policies?
+    // NOTE: in TerraConstruct pre-created policies are passed in through the Grid, so this seems not needed.
+    // private readonly _precreatedPolicy?: IManagedPolicy;
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.description = props.description;
+        this.path = props.path || "/";
+        this.document = props.document ?? new policy_document_1.PolicyDocument(this, "Policy");
+        if (props.managedPolicyName && props.managedPolicyNamePrefix) {
+            throw new Error("Cannot specify both 'managedPolicyName' and 'managedPolicyNamePrefix'. Use only one.");
+        }
+        const managedPolicyNamePrefix = this.stack.uniqueResourceNamePrefix(this, {
+            prefix: props.managedPolicyNamePrefix ?? this.gridUUID + "-",
+            allowedSpecialCharacters: "_+=,.@-",
+            maxLength: 128,
+        });
+        this.resource = new provider_aws_1.iamPolicy.IamPolicy(this, "Resource", {
+            ...props, // copy over Terraform Meta Arguments from ConstructProps
+            name: props.managedPolicyName,
+            namePrefix: !props.managedPolicyName
+                ? managedPolicyNamePrefix
+                : undefined,
+            description: this.description,
+            path: this.path,
+            policy: this.document.json,
+        });
+        if (props.roles) {
+            props.roles.forEach((r) => this.attachToRole(r));
+        }
+        if (props.statements) {
+            props.statements.forEach((p) => this.addStatements(p));
+        }
+        this.grantPrincipal = new ManagedPolicyGrantPrincipal(this);
+        this.node.addValidation({ validate: () => this.validateManagedPolicy() });
+    }
+    /**
+     * Adds a statement to the policy document.
+     */
+    addStatements(...statement) {
+        this.document.addStatements(...statement);
+    }
+    validateManagedPolicy() {
+        const result = new Array();
+        // validate that the policy document is not empty
+        if (this.document.isEmpty) {
+            result.push("Managed Policy is empty. You must add statements to the policy");
+        }
+        result.push(...this.document.validateForIdentityPolicy());
+        return result;
+    }
+}
+exports.ManagedPolicy = ManagedPolicy;
+_a = JSII_RTTI_SYMBOL_1;
+ManagedPolicy[_a] = { fqn: "terraconstructs.aws.iam.ManagedPolicy", version: "0.0.8" };
+class ManagedPolicyGrantPrincipal {
+    constructor(_managedPolicy) {
+        this._managedPolicy = _managedPolicy;
+        this.assumeRoleAction = "sts:AssumeRole";
+        this.grantPrincipal = this;
+        this.principalAccount = _managedPolicy.env.account;
+    }
+    get policyFragment() {
+        // This property is referenced to add policy statements as a resource-based policy.
+        // We should fail because a managed policy cannot be used as a principal of a policy document.
+        // cf. https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html#Principal_specifying
+        throw new Error(`Cannot use a ManagedPolicy '${this._managedPolicy.node.path}' as the 'Principal' or 'NotPrincipal' in an IAM Policy`);
+    }
+    addToPolicy(statement) {
+        return this.addToPrincipalPolicy(statement).statementAdded;
+    }
+    addToPrincipalPolicy(statement) {
+        this._managedPolicy.addStatements(statement);
+        return { statementAdded: true, policyDependable: this._managedPolicy };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"managed-policy.js","sourceRoot":"","sources":["../../../src/aws/iam/managed-policy.ts"],"names":[],"mappings":";;;;;AAAA,sDAI6B;AAE7B,uDAAmD;AASnD,gCAA6B;AAC7B,oDAI0B;AAC1B,4CAAwC;AA0HxC;;GAEG;AACH,MAAe,iBACb,SAAQ,gCAAgB;IASxB,IAAW,oBAAoB;QAC7B,OAAO,EAAE,GAAG,EAAE,IAAI,CAAC,gBAAgB,EAAE,CAAC;IACxC,CAAC;IACD,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,oBAAoB,CAAC;IACnC,CAAC;IAED,YAAY,KAAgB,EAAE,EAAU,EAAE,QAA4B,EAAE;QACtE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QAFT,UAAK,GAAG,IAAI,KAAK,EAAS,CAAC;IAG5C,CAAC;IACM,YAAY,CAAC,IAAW;QAC7B,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YACvD,OAAO;QACT,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxB,CAAC;IACD;;;;OAIG;IACI,WAAW;QAChB,sDAAsD;QACtD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3C,MAAM,EAAE,GAAG,QAAQ,CAAC,EAAE,CAAC;YACvB,mGAAmG;YACnG,4GAA4G;YAC5G,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC;gBAAE,SAAS,CAAC,8BAA8B;YAExE,IAAI,sCAAuB,CAAC,uBAAuB,CAAC,IAAI,EAAE,EAAE,EAAE;gBAC5D,SAAS,EAAE,IAAI,CAAC,gBAAgB;gBAChC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ;aAC7B,CAAC,CAAC;QACL,CAAC;QACD,OAAO,EAAE,CAAC;IACZ,CAAC;CACF;AAED;;GAEG;AACH,MAAa,aACX,SAAQ,iBAAiB;IAGzB;;;;;OAKG;IACI,MAAM,CAAC,qBAAqB,CACjC,KAAgB,EAChB,EAAU,EACV,iBAAyB;QAEzB,MAAM,MAAO,SAAQ,iBAAiB;YAAtC;;gBACkB,qBAAgB,GAAG,oBAAQ,CAAC,cAAc,CACxD,KAAK,CACN,CAAC,SAAS,CAAC;oBACV,OAAO,EAAE,KAAK;oBACd,MAAM,EAAE,EAAE,EAAE,+BAA+B;oBAC3C,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,OAAO;oBACzB,QAAQ,EAAE,QAAQ;oBAClB,YAAY,EAAE,iBAAiB;iBAChC,CAAC,CAAC;YACL,CAAC;SAAA;QACD,OAAO,IAAI,MAAM,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IACnC,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACI,MAAM,CAAC,oBAAoB,CAChC,KAAgB,EAChB,EAAU,EAAE,iDAAiD;IAC7D,gBAAwB;QAExB,4DAA4D;QAC5D,MAAM,MAAO,SAAQ,iBAAiB;YAAtC;;gBACkB,qBAAgB,GAAG,gBAAgB,CAAC;YACtD,CAAC;SAAA;QACD,OAAO,IAAI,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAC/B,CAAC;IAED;;;;;;;;;OASG;IACI,MAAM,CAAC,wBAAwB,CACpC,KAAgB,EAChB,EAAU,EAAE,4CAA4C;IACxD,iBAAyB;QAEzB,MAAM,gBAAiB,SAAQ,iBAAiB;YAAhD;;gBACkB,qBAAgB,GAAG,SAAG,CAAC,MAAM,CAAC;oBAC5C,SAAS,EAAE,IAAI,CAAC,GAAG,CAAC,SAAS;oBAC7B,OAAO,EAAE,KAAK;oBACd,MAAM,EAAE,EAAE,EAAE,+BAA+B;oBAC3C,OAAO,EAAE,KAAK,EAAE,4CAA4C;oBAC5D,QAAQ,EAAE,QAAQ;oBAClB,YAAY,EAAE,iBAAiB;iBAChC,CAAC,CAAC;YACL,CAAC;SAAA;QACD,OAAO,IAAI,gBAAgB,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IACzC,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,oBAAoB,CAChC,WAAsB,EACtB,QAAgB,EAChB,IAA6B;QAE7B,MAAM,MAAO,SAAQ,iBAAiB;YAQpC,YAAY,KAAgB,EAAE,EAAU;gBACtC,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;gBACvB,IAAI,CAAC,QAAQ,GAAG,IAAI,+BAAgB,CAAC,gBAAgB,CACnD,IAAI,EACJ,UAAU,EACV,IAAI,CACL,CAAC;gBACF,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC;YAC5C,CAAC;SACF;QAED,OAAO,IAAI,MAAM,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;IAC3C,CAAC;IACD;;;;OAIG;IACH,IAAW,gBAAgB;QACzB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC;IAC3B,CAAC;IAOD;;;;OAIG;IACH,IAAW,iBAAiB;QAC1B,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;IAC5B,CAAC;IAyBD,8CAA8C;IAC9C,yGAAyG;IACzG,uDAAuD;IAEvD,YAAY,KAAgB,EAAE,EAAU,EAAE,QAA4B,EAAE;QACtE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QAExB,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC;QACrC,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,IAAI,GAAG,CAAC;QAE9B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,IAAI,IAAI,gCAAc,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QAErE,IAAI,KAAK,CAAC,iBAAiB,IAAI,KAAK,CAAC,uBAAuB,EAAE,CAAC;YAC7D,MAAM,IAAI,KAAK,CACb,sFAAsF,CACvF,CAAC;QACJ,CAAC;QAED,MAAM,uBAAuB,GAAG,IAAI,CAAC,KAAK,CAAC,wBAAwB,CAAC,IAAI,EAAE;YACxE,MAAM,EAAE,KAAK,CAAC,uBAAuB,IAAI,IAAI,CAAC,QAAQ,GAAG,GAAG;YAC5D,wBAAwB,EAAE,SAAS;YACnC,SAAS,EAAE,GAAG;SACf,CAAC,CAAC;QAEH,IAAI,CAAC,QAAQ,GAAG,IAAI,wBAAS,CAAC,SAAS,CAAC,IAAI,EAAE,UAAU,EAAE;YACxD,GAAG,KAAK,EAAE,yDAAyD;YACnE,IAAI,EAAE,KAAK,CAAC,iBAAiB;YAC7B,UAAU,EAAE,CAAC,KAAK,CAAC,iBAAiB;gBAClC,CAAC,CAAC,uBAAuB;gBACzB,CAAC,CAAC,SAAS;YACb,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI;SAC3B,CAAC,CAAC;QAEH,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;YAChB,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;QACnD,CAAC;QAED,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;YACrB,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;QACzD,CAAC;QAED,IAAI,CAAC,cAAc,GAAG,IAAI,2BAA2B,CAAC,IAAI,CAAC,CAAC;QAE5D,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,qBAAqB,EAAE,EAAE,CAAC,CAAC;IAC5E,CAAC;IAED;;OAEG;IACI,aAAa,CAAC,GAAG,SAA4B;QAClD,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,GAAG,SAAS,CAAC,CAAC;IAC5C,CAAC;IAEO,qBAAqB;QAC3B,MAAM,MAAM,GAAG,IAAI,KAAK,EAAU,CAAC;QAEnC,iDAAiD;QACjD,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;YAC1B,MAAM,CAAC,IAAI,CACT,gEAAgE,CACjE,CAAC;QACJ,CAAC;QAED,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,yBAAyB,EAAE,CAAC,CAAC;QAC1D,OAAO,MAAM,CAAC;IAChB,CAAC;;AArOH,sCAsOC;;;AAED,MAAM,2BAA2B;IAK/B,YAAoB,cAA6B;QAA7B,mBAAc,GAAd,cAAc,CAAe;QAJjC,qBAAgB,GAAG,gBAAgB,CAAC;QAKlD,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC3B,IAAI,CAAC,gBAAgB,GAAG,cAAc,CAAC,GAAG,CAAC,OAAO,CAAC;IACrD,CAAC;IAED,IAAW,cAAc;QACvB,mFAAmF;QACnF,8FAA8F;QAC9F,uHAAuH;QACvH,MAAM,IAAI,KAAK,CACb,+BAA+B,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,yDAAyD,CACtH,CAAC;IACJ,CAAC;IAEM,WAAW,CAAC,SAA0B;QAC3C,OAAO,IAAI,CAAC,oBAAoB,CAAC,SAAS,CAAC,CAAC,cAAc,CAAC;IAC7D,CAAC;IAEM,oBAAoB,CACzB,SAA0B;QAE1B,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;QAC7C,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,gBAAgB,EAAE,IAAI,CAAC,cAAc,EAAE,CAAC;IACzE,CAAC;CACF","sourcesContent":["import {\n  iamPolicy,\n  dataAwsIamPolicy,\n  iamRolePolicyAttachment,\n} from \"@cdktf/provider-aws\";\nimport { Construct } from \"constructs\";\nimport { PolicyDocument } from \"./policy-document\";\nimport { PolicyStatement } from \"./policy-statement\";\nimport {\n  AddToPrincipalPolicyResult,\n  IGrantable,\n  IPrincipal,\n  PrincipalPolicyFragment,\n} from \"./principals\";\nimport { IRole } from \"./role\";\nimport { Arn } from \"../arn\";\nimport {\n  IAwsConstruct,\n  AwsConstructBase,\n  AwsConstructProps,\n} from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface ManagedPolicyOutputs {\n  readonly arn: string;\n}\n\n/**\n * A managed policy\n */\nexport interface IManagedPolicy extends IAwsConstruct {\n  /**\n   * Strongly typed managed policy outputs\n   *\n   * @attribute\n   */\n  readonly managedPolicyOutputs: ManagedPolicyOutputs;\n  /**\n   * The ARN of the managed policy\n   * @attribute\n   */\n  readonly managedPolicyArn: string;\n  /**\n   * Attaches this policy to a role.\n   *\n   * NOTE: Using this method will conflict with a role that has\n   * exclusive management of the role's policy attachments.\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  attachToRole(role: IRole): void;\n}\n\n/**\n * Properties for defining an IAM managed policy\n */\nexport interface ManagedPolicyProps extends AwsConstructProps {\n  /**\n   * The name of the managed policy. If you specify multiple policies for an entity,\n   * specify unique names. For example, if you specify a list of policies for\n   * an IAM role, each policy must have a unique name.\n   *\n   * Forces new resource\n   *\n   * @default - If omitted, Refer to `managedPolicyNamePrefix`.\n   */\n  readonly managedPolicyName?: string;\n\n  /**\n   * Creates a unique name beginning with the specified prefix.\n   * Conflicts with `managedPolicyName`.\n   *\n   * The name of the managed policy. If you specify multiple policies for an entity,\n   * specify unique names. For example, if you specify a list of policies for\n   * an IAM role, each policy must have a unique name.\n   *\n   * Forces new resource\n   *\n   * @default - If omitted, ET will assign a random, unique name prefixed by GridUUID.\n   */\n  readonly managedPolicyNamePrefix?: string;\n\n  /**\n   * A description of the managed policy. Typically used to store information about the\n   * permissions defined in the policy. For example, \"Grants access to production DynamoDB tables.\"\n   * The policy description is immutable. After a value is assigned, it cannot be changed.\n   *\n   * Forces new resource\n   *\n   * @default - Terraform will generate a description\n   */\n  readonly description?: string;\n\n  //TODO: Confirm terraform generates a description for iam_policy?\n\n  /**\n   * The path for the policy. This parameter allows (through its regex pattern) a string of characters\n   * consisting of either a forward slash (/) by itself or a string that must begin and end with forward slashes.\n   * In addition, it can contain any ASCII character from the ! (\\u0021) through the DEL character (\\u007F),\n   * including most punctuation characters, digits, and upper and lowercased letters.\n   *\n   * For more information about paths, see IAM Identifiers in the IAM User Guide.\n   *\n   * @default - \"/\"\n   */\n  readonly path?: string;\n\n  /**\n   * Roles to attach this policy to.\n   * You can also use `attachToRole(role)` to attach this policy to a role.\n   *\n   * @default - No roles.\n   */\n  readonly roles?: IRole[];\n\n  /**\n   * Initial set of permissions to add to this policy document.\n   * You can also use `addPermission(statement)` to add permissions later.\n   *\n   * @default - No statements.\n   */\n  readonly statements?: PolicyStatement[];\n\n  /**\n   * Initial PolicyDocument to use for this ManagedPolicy. If omited, any\n   * `PolicyStatement` provided in the `statements` property will be applied\n   * against the empty default `PolicyDocument`.\n   *\n   * @default - An empty policy.\n   */\n  readonly document?: PolicyDocument;\n}\n\n/**\n * Attributes to reference ManagedPolicy for plan time failures and strict external dependencies.\n */\nexport interface ManagedPolicyAttributes\n  extends dataAwsIamPolicy.DataAwsIamPolicyConfig {}\n\n/**\n * Managed policy base\n */\nabstract class ManagedPolicyBase\n  extends AwsConstructBase\n  implements IManagedPolicy\n{\n  /**\n   * Returns the ARN of this managed policy.\n   *\n   * @attribute\n   */\n  public abstract get managedPolicyArn(): string;\n  public get managedPolicyOutputs(): ManagedPolicyOutputs {\n    return { arn: this.managedPolicyArn };\n  }\n  public get outputs(): Record<string, any> {\n    return this.managedPolicyOutputs;\n  }\n  private readonly roles = new Array<IRole>();\n  constructor(scope: Construct, id: string, props: ManagedPolicyProps = {}) {\n    super(scope, id, props);\n  }\n  public attachToRole(role: IRole) {\n    if (this.roles.find((r) => r.roleArn === role.roleArn)) {\n      return;\n    }\n    this.roles.push(role);\n  }\n  /**\n   * Adds resource to the terraform JSON output.\n   *\n   * called by TerraformStack.prepareStack()\n   */\n  public toTerraform(): any {\n    // add iamRolePolicy resource for each referenced role\n    for (let i = 0; i < this.roles.length; i++) {\n      const id = `Roles${i}`;\n      // TODO: Ideally we should have used IResolvable.resolve and use the IResolveContext.preparing flag\n      // ref: https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-iam/lib/policy-document.ts#L48\n      if (this.node.tryFindChild(id)) continue; // ignore if already generated\n\n      new iamRolePolicyAttachment.IamRolePolicyAttachment(this, id, {\n        policyArn: this.managedPolicyArn,\n        role: this.roles[i].roleName,\n      });\n    }\n    return {};\n  }\n}\n\n/**\n * Managed policy\n */\nexport class ManagedPolicy\n  extends ManagedPolicyBase\n  implements IManagedPolicy, IGrantable\n{\n  /**\n   * Import a customer managed policy from the managedPolicyName.\n   *\n   * For this managed policy, you only need to know the name to be able to use it.\n   *\n   */\n  public static fromManagedPolicyName(\n    scope: Construct,\n    id: string,\n    managedPolicyName: string,\n  ): IManagedPolicy {\n    class Import extends ManagedPolicyBase {\n      public readonly managedPolicyArn = AwsStack.ofAwsConstruct(\n        scope,\n      ).formatArn({\n        service: \"iam\",\n        region: \"\", // no region for managed policy\n        account: this.env.account,\n        resource: \"policy\",\n        resourceName: managedPolicyName,\n      });\n    }\n    return new Import(scope, id, {});\n  }\n\n  /**\n   * Import an external managed policy by ARN.\n   *\n   * For this managed policy, you only need to know the ARN to be able to use it.\n   * This can be useful if you got the ARN from the Grid.\n   *\n   * If the imported Managed Policy ARN is a Token (such as a\n   * `dataAwsSsmParameter.value` *and* the referenced\n   * managed policy has a `path` (like `arn:...:policy/AdminPolicy/AdminAllow`), the\n   * `managedPolicyName` property will not resolve to the correct value. Instead it\n   * will resolve to the first path component.\n   * In this scenario the Managed Policy ARN should be supplied without the\n   * `path` in order to resolve the correct managed policy resource.\n   *\n   * @param scope construct scope\n   * @param id construct id\n   * @param managedPolicyArn the ARN of the managed policy to import\n   */\n  public static fromManagedPolicyArn(\n    scope: Construct,\n    id: string, // TODO: remove this, use managedPolicyArn as id?\n    managedPolicyArn: string,\n  ): IManagedPolicy {\n    // TODO: Check scope if child already exist and return that?\n    class Import extends ManagedPolicyBase {\n      public readonly managedPolicyArn = managedPolicyArn;\n    }\n    return new Import(scope, id);\n  }\n\n  /**\n   * Import a managed policy from one of the policies that AWS manages.\n   *\n   * For this managed policy, you only need to know the name and scope\n   * to be able to use it.\n   *\n   * Some managed policy names start with \"service-role/\", some start with\n   * \"job-function/\", and some don't start with anything. Include the\n   * prefix when constructing this object.\n   */\n  public static fromAwsManagedPolicyName(\n    scope: Construct,\n    id: string, //TODO: use managedPolicyName as id instead?\n    managedPolicyName: string,\n  ): IManagedPolicy {\n    class AwsManagedPolicy extends ManagedPolicyBase {\n      public readonly managedPolicyArn = Arn.format({\n        partition: this.env.partition,\n        service: \"iam\",\n        region: \"\", // no region for managed policy\n        account: \"aws\", // the account for a managed policy is 'aws'\n        resource: \"policy\",\n        resourceName: managedPolicyName,\n      });\n    }\n    return new AwsManagedPolicy(scope, id);\n  }\n\n  /**\n   * Reference a ManagedPolicy for plan time failures and external dependencies.\n   */\n  public static fromPolicyAttributes(\n    parentScope: Construct,\n    parentId: string,\n    attr: ManagedPolicyAttributes,\n  ): IManagedPolicy {\n    class Import extends ManagedPolicyBase {\n      /**\n       * Direct access to the underlying Terraform resource.\n       *\n       * Use to define dependencies on this ManagedPolicy.\n       */\n      public readonly resource: dataAwsIamPolicy.DataAwsIamPolicy;\n      public readonly managedPolicyArn: string;\n      constructor(scope: Construct, id: string) {\n        super(scope, id, attr);\n        this.resource = new dataAwsIamPolicy.DataAwsIamPolicy(\n          this,\n          \"Resource\",\n          attr,\n        );\n        this.managedPolicyArn = this.resource.arn;\n      }\n    }\n\n    return new Import(parentScope, parentId);\n  }\n  /**\n   * Returns the ARN of this managed policy.\n   *\n   * @attribute\n   */\n  public get managedPolicyArn(): string {\n    return this.resource.arn;\n  }\n\n  /**\n   * The policy document.\n   */\n  public readonly document: PolicyDocument;\n\n  /**\n   * The name of this policy.\n   *\n   * @attribute\n   */\n  public get managedPolicyName(): string {\n    return this.resource.name;\n  }\n\n  /**\n   * The description of this policy.\n   *\n   * @attribute\n   */\n  public readonly description?: string;\n\n  /**\n   * The path of this policy.\n   *\n   * @attribute\n   */\n  public readonly path: string;\n\n  public readonly grantPrincipal: IPrincipal;\n\n  /**\n   * Direct access to the underlying Terraform resource.\n   *\n   * Use to define dependencies on this ManagedPolicy.\n   */\n  public resource: iamPolicy.IamPolicy;\n\n  // TODO: Add support for pre-created policies?\n  // NOTE: in TerraConstruct pre-created policies are passed in through the Grid, so this seems not needed.\n  // private readonly _precreatedPolicy?: IManagedPolicy;\n\n  constructor(scope: Construct, id: string, props: ManagedPolicyProps = {}) {\n    super(scope, id, props);\n\n    this.description = props.description;\n    this.path = props.path || \"/\";\n\n    this.document = props.document ?? new PolicyDocument(this, \"Policy\");\n\n    if (props.managedPolicyName && props.managedPolicyNamePrefix) {\n      throw new Error(\n        \"Cannot specify both 'managedPolicyName' and 'managedPolicyNamePrefix'. Use only one.\",\n      );\n    }\n\n    const managedPolicyNamePrefix = this.stack.uniqueResourceNamePrefix(this, {\n      prefix: props.managedPolicyNamePrefix ?? this.gridUUID + \"-\",\n      allowedSpecialCharacters: \"_+=,.@-\",\n      maxLength: 128,\n    });\n\n    this.resource = new iamPolicy.IamPolicy(this, \"Resource\", {\n      ...props, // copy over Terraform Meta Arguments from ConstructProps\n      name: props.managedPolicyName,\n      namePrefix: !props.managedPolicyName\n        ? managedPolicyNamePrefix\n        : undefined,\n      description: this.description,\n      path: this.path,\n      policy: this.document.json,\n    });\n\n    if (props.roles) {\n      props.roles.forEach((r) => this.attachToRole(r));\n    }\n\n    if (props.statements) {\n      props.statements.forEach((p) => this.addStatements(p));\n    }\n\n    this.grantPrincipal = new ManagedPolicyGrantPrincipal(this);\n\n    this.node.addValidation({ validate: () => this.validateManagedPolicy() });\n  }\n\n  /**\n   * Adds a statement to the policy document.\n   */\n  public addStatements(...statement: PolicyStatement[]) {\n    this.document.addStatements(...statement);\n  }\n\n  private validateManagedPolicy(): string[] {\n    const result = new Array<string>();\n\n    // validate that the policy document is not empty\n    if (this.document.isEmpty) {\n      result.push(\n        \"Managed Policy is empty. You must add statements to the policy\",\n      );\n    }\n\n    result.push(...this.document.validateForIdentityPolicy());\n    return result;\n  }\n}\n\nclass ManagedPolicyGrantPrincipal implements IPrincipal {\n  public readonly assumeRoleAction = \"sts:AssumeRole\";\n  public readonly grantPrincipal: IPrincipal;\n  public readonly principalAccount?: string;\n\n  constructor(private _managedPolicy: ManagedPolicy) {\n    this.grantPrincipal = this;\n    this.principalAccount = _managedPolicy.env.account;\n  }\n\n  public get policyFragment(): PrincipalPolicyFragment {\n    // This property is referenced to add policy statements as a resource-based policy.\n    // We should fail because a managed policy cannot be used as a principal of a policy document.\n    // cf. https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html#Principal_specifying\n    throw new Error(\n      `Cannot use a ManagedPolicy '${this._managedPolicy.node.path}' as the 'Principal' or 'NotPrincipal' in an IAM Policy`,\n    );\n  }\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._managedPolicy.addStatements(statement);\n    return { statementAdded: true, policyDependable: this._managedPolicy };\n  }\n}\n"]}

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

@@ -0,0 +1,120 @@
+import { iamOpenidConnectProvider } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { IAwsConstruct, AwsConstructBase, AwsConstructProps } from "../aws-construct";
+export interface OpenIdConnectProviderOutputs {
+    /**
+     * The Amazon Resource Name (ARN) of the IAM OpenID Connect provider.
+     * @stability stable
+     */
+    readonly arn: string;
+    /**
+     * The issuer for OIDC Provider
+     * @stability stable
+     */
+    readonly issuer: string;
+}
+/**
+ * Represents an IAM OpenID Connect provider.
+ *
+ */
+export interface IOpenIdConnectProvider extends IAwsConstruct {
+    readonly openIdConnectProviderOutputs: OpenIdConnectProviderOutputs;
+    /**
+     * The Amazon Resource Name (ARN) of the IAM OpenID Connect provider.
+     */
+    readonly openIdConnectProviderArn: string;
+    /**
+     * The issuer for OIDC Provider
+     */
+    readonly openIdConnectProviderIssuer: string;
+}
+/**
+ * Initialization properties for `OpenIdConnectProvider`.
+ */
+export interface OpenIdConnectProviderProps extends AwsConstructProps {
+    /**
+     * The URL of the identity provider. The URL must begin with https:// and
+     * should correspond to the iss claim in the provider's OpenID Connect ID
+     * tokens. Per the OIDC standard, path components are allowed but query
+     * parameters are not. Typically the URL consists of only a hostname, like
+     * https://server.example.org or https://example.com.
+     *
+     * You cannot register the same provider multiple times in a single AWS
+     * account. If you try to submit a URL that has already been used for an
+     * OpenID Connect provider in the AWS account, you will get an error.
+     */
+    readonly url: string;
+    /**
+     * A list of client IDs (also known as audiences). When a mobile or web app
+     * registers with an OpenID Connect provider, they establish a value that
+     * identifies the application. (This is the value that's sent as the client_id
+     * parameter on OAuth requests.)
+     *
+     * You can register multiple client IDs with the same provider. For example,
+     * you might have multiple applications that use the same OIDC provider. You
+     * cannot register more than 100 client IDs with a single IAM OIDC provider.
+     *
+     * Client IDs are up to 255 characters long.
+     */
+    readonly clientIds: string[];
+    /**
+     * A list of server certificate thumbprints for the OpenID Connect (OIDC)
+     * identity provider's server certificates.
+     *
+     * AWS secures communication with OIDC identity providers (IdPs) using our
+     * library of trusted root certificate authorities (CAs) to verify the
+     * JSON Web Key Set (JWKS) endpoint's TLS certificate.
+     *
+     * If your OIDC IdP relies on a certificate that is not signed by one of
+     * these trusted CAs, only then we secure communication using the
+     * thumbprints set in the IdP's configuration.
+     *
+     * AWS will fall back to thumbprint verification if we are unable to retrieve
+     * the TLS certificate or if TLS v1.3 is required.
+     *
+     * See [AWS OIDC Docs](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc.html#manage-oidc-provider-console)
+     */
+    readonly thumbprints?: string[];
+}
+/**
+ * IAM OIDC identity providers are entities in IAM that describe an external
+ * identity provider (IdP) service that supports the OpenID Connect (OIDC)
+ * standard, such as Google or Salesforce. You use an IAM OIDC identity provider
+ * when you want to establish trust between an OIDC-compatible IdP and your AWS
+ * account. This is useful when creating a mobile app or web application that
+ * requires access to AWS resources, but you don't want to create custom sign-in
+ * code or manage your own user identities.
+ *
+ * @see http://openid.net/connect
+ * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc.html
+ *
+ * @resource AWS::CloudFormation::CustomResource
+ */
+export declare class OpenIdConnectProvider extends AwsConstructBase implements IOpenIdConnectProvider {
+    /**
+     * Imports an Open ID connect provider from an ARN.
+     * @param scope The definition scope
+     * @param id ID of the construct
+     * @param openIdConnectProviderArn the ARN to import
+     */
+    static fromOpenIdConnectProviderArn(scope: Construct, id: string, openIdConnectProviderArn: string): IOpenIdConnectProvider;
+    readonly openIdConnectProviderOutputs: OpenIdConnectProviderOutputs;
+    get outputs(): Record<string, any>;
+    readonly resource: iamOpenidConnectProvider.IamOpenidConnectProvider;
+    /**
+     * The Amazon Resource Name (ARN) of the IAM OpenID Connect provider.
+     */
+    readonly openIdConnectProviderArn: string;
+    readonly openIdConnectProviderIssuer: string;
+    /**
+     * The thumbprints configured for this provider.
+     */
+    readonly openIdConnectProviderthumbprints: string[];
+    /**
+     * Defines an OpenID Connect provider.
+     * @param scope The definition scope
+     * @param id Construct ID
+     * @param props Initialization properties
+     */
+    constructor(scope: Construct, id: string, props: OpenIdConnectProviderProps);
+}