terraconstructs 0.0.11 → 0.0.13

package/lib/aws/compute/alb/conditions.js

@@ -0,0 +1,164 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListenerCondition = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-elasticloadbalancingv2/lib/alb/conditions.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+/**
+ * ListenerCondition providers definition.
+ */
+class ListenerCondition {
+    /**
+     * Create a host-header listener rule condition
+     *
+     * @param values Hosts for host headers
+     */
+    static hostHeaders(values) {
+        return new HostHeaderListenerCondition(values);
+    }
+    /**
+     * Create a http-header listener rule condition
+     *
+     * @param name HTTP header name
+     * @param values HTTP header values
+     */
+    static httpHeader(name, values) {
+        return new HttpHeaderListenerCondition(name, values);
+    }
+    /**
+     * Create a http-request-method listener rule condition
+     *
+     * @param values HTTP request methods
+     */
+    static httpRequestMethods(values) {
+        return new HttpRequestMethodListenerCondition(values);
+    }
+    /**
+     * Create a path-pattern listener rule condition
+     *
+     * @param values Path patterns
+     */
+    static pathPatterns(values) {
+        return new PathPatternListenerCondition(values);
+    }
+    /**
+     * Create a query-string listener rule condition
+     *
+     * @param values Query string key/value pairs
+     */
+    static queryStrings(values) {
+        return new QueryStringListenerCondition(values);
+    }
+    /**
+     * Create a source-ip listener rule condition
+     *
+     * @param values Source ips
+     */
+    static sourceIps(values) {
+        return new SourceIpListenerCondition(values);
+    }
+}
+exports.ListenerCondition = ListenerCondition;
+_a = JSII_RTTI_SYMBOL_1;
+ListenerCondition[_a] = { fqn: "terraconstructs.aws.compute.ListenerCondition", version: "0.0.13" };
+/**
+ * Host header config of the listener rule condition
+ */
+class HostHeaderListenerCondition extends ListenerCondition {
+    constructor(values) {
+        super();
+        this.values = values;
+    }
+    renderRawCondition() {
+        return provider_aws_1.lbListenerRule.lbListenerRuleConditionToTerraform({
+            hostHeader: {
+                values: this.values,
+            },
+        });
+    }
+}
+/**
+ * HTTP header config of the listener rule condition
+ */
+class HttpHeaderListenerCondition extends ListenerCondition {
+    constructor(name, values) {
+        super();
+        this.name = name;
+        this.values = values;
+    }
+    renderRawCondition() {
+        return provider_aws_1.lbListenerRule.lbListenerRuleConditionToTerraform({
+            httpHeader: {
+                httpHeaderName: this.name,
+                values: this.values,
+            },
+        });
+    }
+}
+/**
+ * HTTP reqeust method config of the listener rule condition
+ */
+class HttpRequestMethodListenerCondition extends ListenerCondition {
+    constructor(values) {
+        super();
+        this.values = values;
+    }
+    renderRawCondition() {
+        return provider_aws_1.lbListenerRule.lbListenerRuleConditionToTerraform({
+            httpRequestMethod: {
+                values: this.values,
+            },
+        });
+    }
+}
+/**
+ * Path pattern config of the listener rule condition
+ */
+class PathPatternListenerCondition extends ListenerCondition {
+    constructor(values) {
+        super();
+        this.values = values;
+        if (values && values.length > 5) {
+            throw new Error("A rule can only have '5' condition values");
+        }
+    }
+    renderRawCondition() {
+        return provider_aws_1.lbListenerRule.lbListenerRuleConditionToTerraform({
+            pathPattern: {
+                values: this.values,
+            },
+        });
+    }
+}
+/**
+ * Query string config of the listener rule condition
+ */
+class QueryStringListenerCondition extends ListenerCondition {
+    constructor(values) {
+        super();
+        this.values = values;
+    }
+    renderRawCondition() {
+        return provider_aws_1.lbListenerRule.lbListenerRuleConditionToTerraform({
+            queryString: this.values,
+        });
+    }
+}
+/**
+ * Source ip config of the listener rule condition
+ */
+class SourceIpListenerCondition extends ListenerCondition {
+    constructor(values) {
+        super();
+        this.values = values;
+    }
+    renderRawCondition() {
+        return provider_aws_1.lbListenerRule.lbListenerRuleConditionToTerraform({
+            sourceIp: {
+                values: this.values,
+            },
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"conditions.js","sourceRoot":"","sources":["../../../../src/aws/compute/alb/conditions.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-elasticloadbalancingv2/lib/alb/conditions.ts\n\nimport { lbListenerRule as tfLbListenerRule } from \"@cdktf/provider-aws\";\n\n/**\n * ListenerCondition providers definition.\n */\nexport abstract class ListenerCondition {\n  /**\n   * Create a host-header listener rule condition\n   *\n   * @param values Hosts for host headers\n   */\n  public static hostHeaders(values: string[]): ListenerCondition {\n    return new HostHeaderListenerCondition(values);\n  }\n\n  /**\n   * Create a http-header listener rule condition\n   *\n   * @param name HTTP header name\n   * @param values HTTP header values\n   */\n  public static httpHeader(name: string, values: string[]): ListenerCondition {\n    return new HttpHeaderListenerCondition(name, values);\n  }\n\n  /**\n   * Create a http-request-method listener rule condition\n   *\n   * @param values HTTP request methods\n   */\n  public static httpRequestMethods(values: string[]): ListenerCondition {\n    return new HttpRequestMethodListenerCondition(values);\n  }\n\n  /**\n   * Create a path-pattern listener rule condition\n   *\n   * @param values Path patterns\n   */\n  public static pathPatterns(values: string[]): ListenerCondition {\n    return new PathPatternListenerCondition(values);\n  }\n\n  /**\n   * Create a query-string listener rule condition\n   *\n   * @param values Query string key/value pairs\n   */\n  public static queryStrings(\n    values: QueryStringCondition[],\n  ): ListenerCondition {\n    return new QueryStringListenerCondition(values);\n  }\n\n  /**\n   * Create a source-ip listener rule condition\n   *\n   * @param values Source ips\n   */\n  public static sourceIps(values: string[]): ListenerCondition {\n    return new SourceIpListenerCondition(values);\n  }\n\n  /**\n   * Render the raw Cfn listener rule condition object.\n   */\n  public abstract renderRawCondition(): any;\n}\n\n/**\n * Properties for the key/value pair of the query string\n */\nexport interface QueryStringCondition {\n  /**\n   * The query string key for the condition\n   *\n   * @default - Any key can be matched.\n   */\n  readonly key?: string;\n\n  /**\n   * The query string value for the condition\n   */\n  readonly value: string;\n}\n\n/**\n * Host header config of the listener rule condition\n */\nclass HostHeaderListenerCondition extends ListenerCondition {\n  constructor(public readonly values: string[]) {\n    super();\n  }\n\n  public renderRawCondition(): any {\n    return tfLbListenerRule.lbListenerRuleConditionToTerraform({\n      hostHeader: {\n        values: this.values,\n      },\n    });\n  }\n}\n\n/**\n * HTTP header config of the listener rule condition\n */\nclass HttpHeaderListenerCondition extends ListenerCondition {\n  constructor(\n    public readonly name: string,\n    public readonly values: string[],\n  ) {\n    super();\n  }\n\n  public renderRawCondition(): any {\n    return tfLbListenerRule.lbListenerRuleConditionToTerraform({\n      httpHeader: {\n        httpHeaderName: this.name,\n        values: this.values,\n      },\n    });\n  }\n}\n\n/**\n * HTTP reqeust method config of the listener rule condition\n */\nclass HttpRequestMethodListenerCondition extends ListenerCondition {\n  constructor(public readonly values: string[]) {\n    super();\n  }\n\n  public renderRawCondition(): any {\n    return tfLbListenerRule.lbListenerRuleConditionToTerraform({\n      httpRequestMethod: {\n        values: this.values,\n      },\n    });\n  }\n}\n\n/**\n * Path pattern config of the listener rule condition\n */\nclass PathPatternListenerCondition extends ListenerCondition {\n  constructor(public readonly values: string[]) {\n    super();\n    if (values && values.length > 5) {\n      throw new Error(\"A rule can only have '5' condition values\");\n    }\n  }\n\n  public renderRawCondition(): any {\n    return tfLbListenerRule.lbListenerRuleConditionToTerraform({\n      pathPattern: {\n        values: this.values,\n      },\n    });\n  }\n}\n\n/**\n * Query string config of the listener rule condition\n */\nclass QueryStringListenerCondition extends ListenerCondition {\n  constructor(public readonly values: QueryStringCondition[]) {\n    super();\n  }\n\n  public renderRawCondition(): any {\n    return tfLbListenerRule.lbListenerRuleConditionToTerraform({\n      queryString: this.values,\n    });\n  }\n}\n\n/**\n * Source ip config of the listener rule condition\n */\nclass SourceIpListenerCondition extends ListenerCondition {\n  constructor(public readonly values: string[]) {\n    super();\n  }\n\n  public renderRawCondition(): any {\n    return tfLbListenerRule.lbListenerRuleConditionToTerraform({\n      sourceIp: {\n        values: this.values,\n      },\n    });\n  }\n}\n"]}

package/lib/aws/compute/alb/trust-store-revocation.d.ts

@@ -0,0 +1,59 @@
+import { Construct } from "constructs";
+import { ITrustStore } from "./trust-store";
+import { AwsConstructBase } from "../../aws-construct";
+import { IBucket } from "../../storage";
+/**
+ * Properties for the trust store revocation
+ */
+export interface TrustStoreRevocationProps {
+    /**
+     * The trust store
+     */
+    readonly trustStore: ITrustStore;
+    /**
+     * The revocation file to add
+     */
+    readonly revocationContents: RevocationContent[];
+}
+/**
+ * Information about a revocation file
+ */
+export interface RevocationContent {
+    /**
+     * The type of revocation file
+     *
+     * @default RevocationType.CRL
+     */
+    readonly revocationType?: RevocationType;
+    /**
+     * The Amazon S3 bucket for the revocation file
+     */
+    readonly bucket: IBucket;
+    /**
+     * The Amazon S3 path for the revocation file
+     */
+    readonly key: string;
+    /**
+     * The Amazon S3 object version of the revocation file
+     *
+     * @default - latest version
+     */
+    readonly version?: string;
+}
+/**
+ * The type of revocation file
+ */
+export declare enum RevocationType {
+    /**
+     * A signed list of revoked certificates
+     */
+    CRL = "CRL"
+}
+/**
+ * A new Trust Store Revocation
+ */
+export declare class TrustStoreRevocation extends AwsConstructBase {
+    get outputs(): Record<string, any>;
+    private readonly revocations;
+    constructor(scope: Construct, id: string, props: TrustStoreRevocationProps);
+}

package/lib/aws/compute/alb/trust-store-revocation.js

@@ -0,0 +1,46 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrustStoreRevocation = exports.RevocationType = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-elasticloadbalancingv2/lib/alb/trust-store-revocation.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const aws_construct_1 = require("../../aws-construct");
+/**
+ * The type of revocation file
+ */
+var RevocationType;
+(function (RevocationType) {
+    /**
+     * A signed list of revoked certificates
+     */
+    RevocationType["CRL"] = "CRL";
+})(RevocationType || (exports.RevocationType = RevocationType = {}));
+/**
+ * A new Trust Store Revocation
+ */
+class TrustStoreRevocation extends aws_construct_1.AwsConstructBase {
+    get outputs() {
+        return {
+            revocationIds: this.revocations.map((r) => r.revocationId),
+        };
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.revocations = new Array();
+        props.revocationContents?.map((content) => {
+            this.revocations.push(new provider_aws_1.lbTrustStoreRevocation.LbTrustStoreRevocation(this, "Resource", {
+                trustStoreArn: props.trustStore.trustStoreArn,
+                // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancingv2-truststorerevocation-revocationcontent.html
+                // revocationType: content.revocationType,
+                revocationsS3Bucket: content.bucket.bucketName,
+                revocationsS3Key: content.key,
+                revocationsS3ObjectVersion: content.version,
+            }));
+        });
+    }
+}
+exports.TrustStoreRevocation = TrustStoreRevocation;
+_a = JSII_RTTI_SYMBOL_1;
+TrustStoreRevocation[_a] = { fqn: "terraconstructs.aws.compute.TrustStoreRevocation", version: "0.0.13" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/compute/alb/trust-store.d.ts

@@ -0,0 +1,86 @@
+import { Construct } from "constructs";
+import { IAwsConstruct, AwsConstructBase, AwsConstructProps } from "../../aws-construct";
+import { IBucket } from "../../storage";
+/**
+ * Outputs which may be registered for output via the Grid.
+ */
+export interface TrustStoreOutputs {
+    /**
+     * The name of the trust store
+     * @attribute
+     */
+    readonly trustStoreName: string;
+    /**
+     * The ARN of the trust store
+     * @attribute
+     */
+    readonly trustStoreArn: string;
+}
+/**
+ * Represents a Trust Store
+ */
+export interface ITrustStore extends IAwsConstruct {
+    /** Strongly typed outputs */
+    readonly trustStoreOutputs: TrustStoreOutputs;
+    /**
+     * The name of the trust store
+     * @attribute
+     */
+    readonly trustStoreName: string;
+    /**
+     * The ARN of the trust store
+     * @attribute
+     */
+    readonly trustStoreArn: string;
+}
+/**
+ * Properties used for the Trust Store
+ */
+export interface TrustStoreProps extends AwsConstructProps {
+    /**
+     * The name of the trust store
+     *
+     * @default - Auto generated
+     */
+    readonly trustStoreName?: string;
+    /**
+     * The bucket that the trust store is hosted in
+     */
+    readonly bucket: IBucket;
+    /**
+     * The key in S3 to look at for the trust store
+     */
+    readonly key: string;
+    /**
+     * The version of the S3 object that contains your truststore.
+     * To specify a version, you must have versioning enabled for the S3 bucket.
+     *
+     * @default - latest version
+     */
+    readonly version?: string;
+}
+/**
+ * A new Trust Store
+ */
+export declare class TrustStore extends AwsConstructBase implements ITrustStore {
+    /**
+     * Import from ARN
+     */
+    static fromTrustStoreArn(scope: Construct, id: string, trustStoreArn: string): ITrustStore;
+    get trustStoreOutputs(): TrustStoreOutputs;
+    get outputs(): Record<string, any>;
+    /**
+     * The name of the trust store
+     *
+     * @attribute
+     */
+    readonly trustStoreName: string;
+    /**
+     * The ARN of the trust store
+     *
+     * @attribute
+     */
+    readonly trustStoreArn: string;
+    private physicalName;
+    constructor(scope: Construct, id: string, props: TrustStoreProps);
+}

package/lib/aws/compute/alb/trust-store.js

@@ -0,0 +1,79 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrustStore = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-elasticloadbalancingv2/lib/alb/trust-store.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const aws_construct_1 = require("../../aws-construct");
+/**
+ * A new Trust Store
+ */
+class TrustStore extends aws_construct_1.AwsConstructBase {
+    /**
+     * Import from ARN
+     */
+    static fromTrustStoreArn(scope, id, trustStoreArn) {
+        const resourceParts = cdktf_1.Fn.split("/", trustStoreArn);
+        const trustStoreName = cdktf_1.Fn.element(resourceParts, 0);
+        class Import extends aws_construct_1.AwsConstructBase {
+            constructor() {
+                super(...arguments);
+                this.trustStoreArn = trustStoreArn;
+                this.trustStoreName = trustStoreName;
+            }
+            get trustStoreOutputs() {
+                return {
+                    trustStoreName: this.trustStoreName,
+                    trustStoreArn: this.trustStoreArn,
+                };
+            }
+            get outputs() {
+                return this.trustStoreOutputs;
+            }
+        }
+        return new Import(scope, id);
+    }
+    get trustStoreOutputs() {
+        return {
+            trustStoreName: this.trustStoreName,
+            trustStoreArn: this.trustStoreArn,
+        };
+    }
+    get outputs() {
+        return this.trustStoreOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.physicalName =
+            props.trustStoreName ??
+                this.stack.uniqueResourceName(this, { maxLength: 32 });
+        if (props.trustStoreName !== undefined &&
+            !cdktf_1.Token.isUnresolved(props.trustStoreName)) {
+            if (props.trustStoreName.length < 1 || props.trustStoreName.length > 32) {
+                throw new Error(`trustStoreName '${props.trustStoreName}' must be 1-32 characters long.`);
+            }
+            const validNameRegex = /^([a-zA-Z0-9]+-)*[a-zA-Z0-9]+$/;
+            if (!validNameRegex.test(props.trustStoreName)) {
+                throw new Error(`trustStoreName '${props.trustStoreName}' must contain only alphanumeric characters and hyphens, and cannot begin or end with a hyphen.`);
+            }
+        }
+        const resource = new provider_aws_1.lbTrustStore.LbTrustStore(this, "Resource", {
+            name: this.physicalName,
+            caCertificatesBundleS3Bucket: props.bucket.bucketName,
+            caCertificatesBundleS3Key: props.key,
+            caCertificatesBundleS3ObjectVersion: props.version,
+        });
+        this.trustStoreName = resource.name;
+        this.trustStoreArn = resource.arn;
+        // TODO: provider-aws doesn't have numberOfCaCertificates?
+        // this.numberOfCaCertificates = resource.numberOfCaCertificates;
+        // TODO: provider-aws doesn't have status?
+        // this.status = resource.status;
+    }
+}
+exports.TrustStore = TrustStore;
+_a = JSII_RTTI_SYMBOL_1;
+TrustStore[_a] = { fqn: "terraconstructs.aws.compute.TrustStore", version: "0.0.13" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trust-store.js","sourceRoot":"","sources":["../../../../src/aws/compute/alb/trust-store.ts"],"names":[],"mappings":";;;;;AAAA,sHAAsH;AAEtH,sDAAmE;AACnE,iCAAkC;AAElC,uDAI6B;AAqE7B;;GAEG;AACH,MAAa,UAAW,SAAQ,gCAAgB;IAC9C;;OAEG;IACI,MAAM,CAAC,iBAAiB,CAC7B,KAAgB,EAChB,EAAU,EACV,aAAqB;QAErB,MAAM,aAAa,GAAG,UAAE,CAAC,KAAK,CAAC,GAAG,EAAE,aAAa,CAAC,CAAC;QAEnD,MAAM,cAAc,GAAG,UAAE,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;QAEpD,MAAM,MAAO,SAAQ,gCAAgB;YAArC;;gBAUkB,kBAAa,GAAG,aAAa,CAAC;gBAC9B,mBAAc,GAAG,cAAc,CAAC;YAClD,CAAC;YAXC,IAAW,iBAAiB;gBAC1B,OAAO;oBACL,cAAc,EAAE,IAAI,CAAC,cAAc;oBACnC,aAAa,EAAE,IAAI,CAAC,aAAa;iBAClC,CAAC;YACJ,CAAC;YACD,IAAW,OAAO;gBAChB,OAAO,IAAI,CAAC,iBAAiB,CAAC;YAChC,CAAC;SAGF;QACD,OAAO,IAAI,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAC/B,CAAC;IAED,IAAW,iBAAiB;QAC1B,OAAO;YACL,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,aAAa,EAAE,IAAI,CAAC,aAAa;SAClC,CAAC;IACJ,CAAC;IACD,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAChC,CAAC;IAiCD,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAsB;QAC9D,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QACxB,IAAI,CAAC,YAAY;YACf,KAAK,CAAC,cAAc;gBACpB,IAAI,CAAC,KAAK,CAAC,kBAAkB,CAAC,IAAI,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,CAAC;QAEzD,IACE,KAAK,CAAC,cAAc,KAAK,SAAS;YAClC,CAAC,aAAK,CAAC,YAAY,CAAC,KAAK,CAAC,cAAc,CAAC,EACzC,CAAC;YACD,IAAI,KAAK,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,CAAC,cAAc,CAAC,MAAM,GAAG,EAAE,EAAE,CAAC;gBACxE,MAAM,IAAI,KAAK,CACb,mBAAmB,KAAK,CAAC,cAAc,iCAAiC,CACzE,CAAC;YACJ,CAAC;YACD,MAAM,cAAc,GAAG,gCAAgC,CAAC;YACxD,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,EAAE,CAAC;gBAC/C,MAAM,IAAI,KAAK,CACb,mBAAmB,KAAK,CAAC,cAAc,iGAAiG,CACzI,CAAC;YACJ,CAAC;QACH,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,2BAAY,CAAC,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE;YAC/D,IAAI,EAAE,IAAI,CAAC,YAAY;YACvB,4BAA4B,EAAE,KAAK,CAAC,MAAM,CAAC,UAAU;YACrD,yBAAyB,EAAE,KAAK,CAAC,GAAG;YACpC,mCAAmC,EAAE,KAAK,CAAC,OAAO;SACnD,CAAC,CAAC;QAEH,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC,IAAI,CAAC;QACpC,IAAI,CAAC,aAAa,GAAG,QAAQ,CAAC,GAAG,CAAC;QAClC,0DAA0D;QAC1D,iEAAiE;QACjE,0CAA0C;QAC1C,iCAAiC;IACnC,CAAC;;AA1GH,gCA2GC","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-elasticloadbalancingv2/lib/alb/trust-store.ts\n\nimport { lbTrustStore as tfTrustStore } from \"@cdktf/provider-aws\";\nimport { Fn, Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  IAwsConstruct,\n  AwsConstructBase,\n  AwsConstructProps,\n} from \"../../aws-construct\";\nimport { IBucket } from \"../../storage\";\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface TrustStoreOutputs {\n  /**\n   * The name of the trust store\n   * @attribute\n   */\n  readonly trustStoreName: string;\n\n  /**\n   * The ARN of the trust store\n   * @attribute\n   */\n  readonly trustStoreArn: string;\n}\n\n/**\n * Represents a Trust Store\n */\nexport interface ITrustStore extends IAwsConstruct {\n  /** Strongly typed outputs */\n  readonly trustStoreOutputs: TrustStoreOutputs;\n  /**\n   * The name of the trust store\n   * @attribute\n   */\n  readonly trustStoreName: string;\n\n  /**\n   * The ARN of the trust store\n   * @attribute\n   */\n  readonly trustStoreArn: string;\n}\n\n/**\n * Properties used for the Trust Store\n */\nexport interface TrustStoreProps extends AwsConstructProps {\n  /**\n   * The name of the trust store\n   *\n   * @default - Auto generated\n   */\n  readonly trustStoreName?: string;\n\n  /**\n   * The bucket that the trust store is hosted in\n   */\n  readonly bucket: IBucket;\n\n  /**\n   * The key in S3 to look at for the trust store\n   */\n  readonly key: string;\n\n  /**\n   * The version of the S3 object that contains your truststore.\n   * To specify a version, you must have versioning enabled for the S3 bucket.\n   *\n   * @default - latest version\n   */\n  readonly version?: string;\n}\n\n/**\n * A new Trust Store\n */\nexport class TrustStore extends AwsConstructBase implements ITrustStore {\n  /**\n   * Import from ARN\n   */\n  public static fromTrustStoreArn(\n    scope: Construct,\n    id: string,\n    trustStoreArn: string,\n  ): ITrustStore {\n    const resourceParts = Fn.split(\"/\", trustStoreArn);\n\n    const trustStoreName = Fn.element(resourceParts, 0);\n\n    class Import extends AwsConstructBase implements ITrustStore {\n      public get trustStoreOutputs(): TrustStoreOutputs {\n        return {\n          trustStoreName: this.trustStoreName,\n          trustStoreArn: this.trustStoreArn,\n        };\n      }\n      public get outputs(): Record<string, any> {\n        return this.trustStoreOutputs;\n      }\n      public readonly trustStoreArn = trustStoreArn;\n      public readonly trustStoreName = trustStoreName;\n    }\n    return new Import(scope, id);\n  }\n\n  public get trustStoreOutputs(): TrustStoreOutputs {\n    return {\n      trustStoreName: this.trustStoreName,\n      trustStoreArn: this.trustStoreArn,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.trustStoreOutputs;\n  }\n\n  /**\n   * The name of the trust store\n   *\n   * @attribute\n   */\n  public readonly trustStoreName: string;\n\n  // TODO: provider-aws doesn't have numberOfCaCertificates?\n  // /**\n  //  * The number of CA certificates in the trust store\n  //  *\n  //  * @attribute\n  //  */\n  // public readonly numberOfCaCertificates: number;\n\n  // TODO: provider-aws doesn't have status?\n  // /**\n  //  * The status of the trust store\n  //  *\n  //  * @attribute\n  //  */\n  // public readonly status: string;\n\n  /**\n   * The ARN of the trust store\n   *\n   * @attribute\n   */\n  public readonly trustStoreArn: string;\n  private physicalName: string;\n\n  constructor(scope: Construct, id: string, props: TrustStoreProps) {\n    super(scope, id, props);\n    this.physicalName =\n      props.trustStoreName ??\n      this.stack.uniqueResourceName(this, { maxLength: 32 });\n\n    if (\n      props.trustStoreName !== undefined &&\n      !Token.isUnresolved(props.trustStoreName)\n    ) {\n      if (props.trustStoreName.length < 1 || props.trustStoreName.length > 32) {\n        throw new Error(\n          `trustStoreName '${props.trustStoreName}' must be 1-32 characters long.`,\n        );\n      }\n      const validNameRegex = /^([a-zA-Z0-9]+-)*[a-zA-Z0-9]+$/;\n      if (!validNameRegex.test(props.trustStoreName)) {\n        throw new Error(\n          `trustStoreName '${props.trustStoreName}' must contain only alphanumeric characters and hyphens, and cannot begin or end with a hyphen.`,\n        );\n      }\n    }\n\n    const resource = new tfTrustStore.LbTrustStore(this, \"Resource\", {\n      name: this.physicalName,\n      caCertificatesBundleS3Bucket: props.bucket.bucketName,\n      caCertificatesBundleS3Key: props.key,\n      caCertificatesBundleS3ObjectVersion: props.version,\n    });\n\n    this.trustStoreName = resource.name;\n    this.trustStoreArn = resource.arn;\n    // TODO: provider-aws doesn't have numberOfCaCertificates?\n    // this.numberOfCaCertificates = resource.numberOfCaCertificates;\n    // TODO: provider-aws doesn't have status?\n    // this.status = resource.status;\n  }\n}\n"]}

package/lib/aws/compute/architecture.js

@@ -30,7 +30,7 @@ class Architecture {
 }
 exports.Architecture = Architecture;
 _a = JSII_RTTI_SYMBOL_1;
-Architecture[_a] = { fqn: "terraconstructs.aws.compute.Architecture", version: "0.0.11" };
+Architecture[_a] = { fqn: "terraconstructs.aws.compute.Architecture", version: "0.0.13" };
 /**
  * 64 bit architecture with x86 instruction set.
  */

package/lib/aws/compute/aspects/require-imdsv2-aspect.d.ts

@@ -0,0 +1,75 @@
+import { IAspect } from "cdktf";
+import { IConstruct } from "constructs";
+/**
+ * Properties for `RequireImdsv2Aspect`.
+ */
+interface RequireImdsv2AspectProps {
+    /**
+     * Whether warning annotations from this Aspect should be suppressed or not.
+     *
+     * @default - false
+     */
+    readonly suppressWarnings?: boolean;
+}
+/**
+ * Base class for Aspect that makes IMDSv2 required.
+ */
+declare abstract class RequireImdsv2Aspect implements IAspect {
+    protected readonly suppressWarnings: boolean;
+    constructor(props?: RequireImdsv2AspectProps);
+    abstract visit(node: IConstruct): void;
+    /**
+     * Adds a warning annotation to a node, unless `suppressWarnings` is true.
+     *
+     * @param node The scope to add the warning to.
+     * @param message The warning message.
+     */
+    protected warn(node: IConstruct, message: string): void;
+}
+/**
+ * Properties for `InstanceRequireImdsv2Aspect`.
+ */
+export interface InstanceRequireImdsv2AspectProps extends RequireImdsv2AspectProps {
+    /**
+     * Whether warnings that would be raised when an Instance is associated with an existing Launch Template
+     * should be suppressed or not.
+     *
+     * You can set this to `true` if `LaunchTemplateImdsAspect` is being used alongside this Aspect to
+     * suppress false-positive warnings because any Launch Templates associated with Instances will still be covered.
+     *
+     * @default - false
+     */
+    readonly suppressLaunchTemplateWarning?: boolean;
+}
+/**
+ * Aspect that applies IMDS configuration on EC2 Instance constructs.
+ *
+ * This aspect configures IMDS on an EC2 instance by creating a Launch Template with the
+ * IMDS configuration and associating that Launch Template with the instance. If an Instance
+ * is already associated with a Launch Template, a warning will (optionally) be added to the
+ * construct node and it will be skipped.
+ *
+ * To cover Instances already associated with Launch Templates, use `LaunchTemplateImdsAspect`.
+ */
+export declare class InstanceRequireImdsv2Aspect extends RequireImdsv2Aspect {
+    private readonly suppressLaunchTemplateWarning;
+    constructor(props?: InstanceRequireImdsv2AspectProps);
+    visit(node: IConstruct): void;
+    protected warn(node: IConstruct, message: string): void;
+}
+/**
+ * Properties for `LaunchTemplateRequireImdsv2Aspect`.
+ */
+export interface LaunchTemplateRequireImdsv2AspectProps extends RequireImdsv2AspectProps {
+}
+/**
+ * Aspect that applies IMDS configuration on EC2 Launch Template constructs.
+ *
+ * @see https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/launch_template#metadata-options
+ * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html
+ */
+export declare class LaunchTemplateRequireImdsv2Aspect extends RequireImdsv2Aspect {
+    constructor(props?: LaunchTemplateRequireImdsv2AspectProps);
+    visit(node: IConstruct): void;
+}
+export {};