@aws-cdk/aws-certificatemanager - npm Package Compare versions

Comparing version 1.51.0 to 1.52.0

lambda-packages/dns_validated_certificate_handler/package.json

 {
   "name": "dns_validated_certificate_handler",
   "private": true,
-  "version": "1.51.0",
+  "version": "1.52.0",
   "description": "This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aws-cdk) project.",
@@ -13,3 +13,3 @@ "main": "lib/index.js",
     "test": "jest",
-    "lint": "eslint lib",
+    "eslint": "eslint lib",
     "build+test+package": "npm run build+test",
@@ -16,0 +16,0 @@ "build+test": "npm run build && npm test"

lib/certificate.d.ts

@@ -0,1 +1,2 @@
+import * as route53 from '@aws-cdk/aws-route53';
 import { Construct, IResource, Resource } from '@aws-cdk/core';
@@ -37,2 +38,3 @@ /**
      * @default - Apex domain is used for every domain that's not overridden.
+     * @deprecated use `validation` instead.
      */
@@ -46,21 +48,101 @@ readonly validationDomains?: {
      * @default ValidationMethod.EMAIL
+     * @deprecated use `validation` instead.
      */
     readonly validationMethod?: ValidationMethod;
+    /**
+     * How to validate this certifcate
+     *
+     * @default CertificateValidation.fromEmail()
+     */
+    readonly validation?: CertificateValidation;
 }
 /**
+ * Properties for certificate validation
+ */
+export interface CertificationValidationProps {
+    /**
+     * Validation method
+     *
+     * @default ValidationMethod.EMAIL
+     */
+    readonly method?: ValidationMethod;
+    /**
+     * Hosted zone to use for DNS validation
+     *
+     * @default - use email validation
+     */
+    readonly hostedZone?: route53.IHostedZone;
+    /**
+     * A map of hosted zones to use for DNS validation
+     *
+     * @default - use `hostedZone`
+     */
+    readonly hostedZones?: {
+        [domainName: string]: route53.IHostedZone;
+    };
+    /**
+     * Validation domains to use for email validation
+     *
+     * @default - Apex domain
+     */
+    readonly validationDomains?: {
+        [domainName: string]: string;
+    };
+}
+/**
+ * How to validate a certificate
+ */
+export declare class CertificateValidation {
+    readonly props: CertificationValidationProps;
+    /**
+     * Validate the certifcate with DNS
+     *
+     * IMPORTANT: If `hostedZone` is not specified, DNS records must be added
+     * manually and the stack will not complete creating until the records are
+     * added.
+     *
+     * @param hostedZone the hosted zone where DNS records must be created
+     */
+    static fromDns(hostedZone?: route53.IHostedZone): CertificateValidation;
+    /**
+     * Validate the certifcate with automatically created DNS records in multiple
+     * Amazon Route 53 hosted zones.
+     *
+     * @param hostedZones a map of hosted zones where DNS records must be created
+     * for the domains in the certificate
+     */
+    static fromDnsMultiZone(hostedZones: {
+        [domainName: string]: route53.IHostedZone;
+    }): CertificateValidation;
+    /**
+     * Validate the certifcate with Email
+     *
+     * IMPORTANT: if you are creating a certificate as part of your stack, the stack
+     * will not complete creating until you read and follow the instructions in the
+     * email that you will receive.
+     *
+     * ACM will send validation emails to the following addresses:
+     *
+     *  [e-mail]
+     *  [e-mail]
+     *  [e-mail]
+     *  [e-mail]
+     *  [e-mail]
+     *
+     * For every domain that you register.
+     *
+     * @param validationDomains a map of validation domains to use for domains in the certificate
+     */
+    static fromEmail(validationDomains?: {
+        [domainName: string]: string;
+    }): CertificateValidation;
+    /**
+     * The validation method
+     */
+    readonly method: ValidationMethod;
+    /** @param props Certification validation properties */
+    private constructor();
+}
+/**
  * A certificate managed by AWS Certificate Manager
- *
- * IMPORTANT: if you are creating a certificate as part of your stack, the stack
- * will not complete creating until you read and follow the instructions in the
- * email that you will receive.
- *
- * ACM will send validation emails to the following addresses:
- *
- *  [e-mail]
- *  [e-mail]
- *  [e-mail]
- *  [e-mail]
- *  [e-mail]
- *
- * For every domain that you register.
  */
@@ -67,0 +149,0 @@ export declare class Certificate extends Resource implements ICertificate {

lib/certificate.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValidationMethod = exports.Certificate = void 0;
+exports.ValidationMethod = exports.Certificate = exports.CertificateValidation = void 0;
 const core_1 = require("@aws-cdk/core");
@@ -8,17 +8,68 @@ const certificatemanager_generated_1 = require("./certificatemanager.generated");
 /**
+ * How to validate a certificate
+ */
+class CertificateValidation {
+    /** @param props Certification validation properties */
+    constructor(props) {
+        var _a;
+        this.props = props;
+        this.method = (_a = props.method) !== null && _a !== void 0 ? _a : ValidationMethod.EMAIL;
+    }
+    /**
+     * Validate the certifcate with DNS
+     *
+     * IMPORTANT: If `hostedZone` is not specified, DNS records must be added
+     * manually and the stack will not complete creating until the records are
+     * added.
+     *
+     * @param hostedZone the hosted zone where DNS records must be created
+     */
+    static fromDns(hostedZone) {
+        return new CertificateValidation({
+            method: ValidationMethod.DNS,
+            hostedZone,
+        });
+    }
+    /**
+     * Validate the certifcate with automatically created DNS records in multiple
+     * Amazon Route 53 hosted zones.
+     *
+     * @param hostedZones a map of hosted zones where DNS records must be created
+     * for the domains in the certificate
+     */
+    static fromDnsMultiZone(hostedZones) {
+        return new CertificateValidation({
+            method: ValidationMethod.DNS,
+            hostedZones,
+        });
+    }
+    /**
+     * Validate the certifcate with Email
+     *
+     * IMPORTANT: if you are creating a certificate as part of your stack, the stack
+     * will not complete creating until you read and follow the instructions in the
+     * email that you will receive.
+     *
+     * ACM will send validation emails to the following addresses:
+     *
+     *  [e-mail]
+     *  [e-mail]
+     *  [e-mail]
+     *  [e-mail]
+     *  [e-mail]
+     *
+     * For every domain that you register.
+     *
+     * @param validationDomains a map of validation domains to use for domains in the certificate
+     */
+    static fromEmail(validationDomains) {
+        return new CertificateValidation({
+            method: ValidationMethod.EMAIL,
+            validationDomains,
+        });
+    }
+}
+exports.CertificateValidation = CertificateValidation;
+/**
  * A certificate managed by AWS Certificate Manager
- *
- * IMPORTANT: if you are creating a certificate as part of your stack, the stack
- * will not complete creating until you read and follow the instructions in the
- * email that you will receive.
- *
- * ACM will send validation emails to the following addresses:
- *
- *  [e-mail]
- *  [e-mail]
- *  [e-mail]
- *  [e-mail]
- *  [e-mail]
- *
- * For every domain that you register.
  */
@@ -28,2 +79,14 @@ class Certificate extends core_1.Resource {
         super(scope, id);
+        let validation;
+        if (props.validation) {
+            validation = props.validation;
+        }
+        else { // Deprecated props
+            if (props.validationMethod === ValidationMethod.DNS) {
+                validation = CertificateValidation.fromDns();
+            }
+            else {
+                validation = CertificateValidation.fromEmail(props.validationDomains);
+            }
+        }
         const allDomainNames = [props.domainName].concat(props.subjectAlternativeNames || []);
@@ -33,21 +96,6 @@ const cert = new certificatemanager_generated_1.CfnCertificate(this, 'Resource', {
             subjectAlternativeNames: props.subjectAlternativeNames,
-            domainValidationOptions: allDomainNames.map(domainValidationOption),
-            validationMethod: props.validationMethod,
+            domainValidationOptions: renderDomainValidation(validation, allDomainNames),
+            validationMethod: validation.method,
         });
         this.certificateArn = cert.ref;
-        /**
-         * Return the domain validation options for the given domain
-         *
-         * Closes over props.
-         */
-        function domainValidationOption(domainName) {
-            let validationDomain = props.validationDomains && props.validationDomains[domainName];
-            if (validationDomain === undefined) {
-                if (core_1.Token.isUnresolved(domainName)) {
-                    throw new Error('When using Tokens for domain names, \'validationDomains\' needs to be supplied');
-                }
-                validationDomain = util_1.apexDomain(domainName);
-            }
-            return { domainName, validationDomain };
-        }
     }
@@ -86,2 +134,29 @@ /**
 })(ValidationMethod = exports.ValidationMethod || (exports.ValidationMethod = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2VydGlmaWNhdGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJjZXJ0aWZpY2F0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSx3Q0FBc0U7QUFDdEUsaUZBQWdFO0FBQ2hFLGlDQUFvQztBQW1EcEM7Ozs7Ozs7Ozs7Ozs7Ozs7R0FnQkc7QUFDSCxNQUFhLFdBQVksU0FBUSxlQUFRO0lBa0J2QyxZQUFZLEtBQWdCLEVBQUUsRUFBVSxFQUFFLEtBQXVCO1FBQy9ELEtBQUssQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFFakIsTUFBTSxjQUFjLEdBQUcsQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyx1QkFBdUIsSUFBSSxFQUFFLENBQUMsQ0FBQztRQUV0RixNQUFNLElBQUksR0FBRyxJQUFJLDZDQUFjLENBQUMsSUFBSSxFQUFFLFVBQVUsRUFBRTtZQUNoRCxVQUFVLEVBQUUsS0FBSyxDQUFDLFVBQVU7WUFDNUIsdUJBQXVCLEVBQUUsS0FBSyxDQUFDLHVCQUF1QjtZQUN0RCx1QkFBdUIsRUFBRSxjQUFjLENBQUMsR0FBRyxDQUFDLHNCQUFzQixDQUFDO1lBQ25FLGdCQUFnQixFQUFFLEtBQUssQ0FBQyxnQkFBZ0I7U0FDekMsQ0FBQyxDQUFDO1FBRUgsSUFBSSxDQUFDLGNBQWMsR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDO1FBRS9COzs7O1dBSUc7UUFDSCxTQUFTLHNCQUFzQixDQUFDLFVBQWtCO1lBQ2hELElBQUksZ0JBQWdCLEdBQUcsS0FBSyxDQUFDLGlCQUFpQixJQUFJLEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxVQUFVLENBQUMsQ0FBQztZQUN0RixJQUFJLGdCQUFnQixLQUFLLFNBQVMsRUFBRTtnQkFDbEMsSUFBSSxZQUFLLENBQUMsWUFBWSxDQUFDLFVBQVUsQ0FBQyxFQUFFO29CQUNsQyxNQUFNLElBQUksS0FBSyxDQUFDLGdGQUFnRixDQUFDLENBQUM7aUJBQ25HO2dCQUNELGdCQUFnQixHQUFHLGlCQUFVLENBQUMsVUFBVSxDQUFDLENBQUM7YUFDM0M7WUFFRCxPQUFPLEVBQUUsVUFBVSxFQUFFLGdCQUFnQixFQUFFLENBQUM7UUFDMUMsQ0FBQztJQUNILENBQUM7SUE5Q0Q7O09BRUc7SUFDSSxNQUFNLENBQUMsa0JBQWtCLENBQUMsS0FBZ0IsRUFBRSxFQUFVLEVBQUUsY0FBc0I7UUFDbkYsTUFBTSxNQUFPLFNBQVEsZUFBUTtZQUE3Qjs7Z0JBQ1MsbUJBQWMsR0FBRyxjQUFjLENBQUM7WUFDekMsQ0FBQztTQUFBO1FBRUQsT0FBTyxJQUFJLE1BQU0sQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFDL0IsQ0FBQztDQXNDRjtBQWpERCxrQ0FpREM7QUFFRDs7R0FFRztBQUNILElBQVksZ0JBY1g7QUFkRCxXQUFZLGdCQUFnQjtJQUMxQjs7OztPQUlHO0lBQ0gsbUNBQWUsQ0FBQTtJQUVmOzs7O09BSUc7SUFDSCwrQkFBVyxDQUFBO0FBQ2IsQ0FBQyxFQWRXLGdCQUFnQixHQUFoQix3QkFBZ0IsS0FBaEIsd0JBQWdCLFFBYzNCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29uc3RydWN0LCBJUmVzb3VyY2UsIFJlc291cmNlLCBUb2tlbiB9IGZyb20gJ0Bhd3MtY2RrL2NvcmUnO1xuaW1wb3J0IHsgQ2ZuQ2VydGlmaWNhdGUgfSBmcm9tICcuL2NlcnRpZmljYXRlbWFuYWdlci5nZW5lcmF0ZWQnO1xuaW1wb3J0IHsgYXBleERvbWFpbiB9IGZyb20gJy4vdXRpbCc7XG5cbi8qKlxuICogUmVwcmVzZW50cyBhIGNlcnRpZmljYXRlIGluIEFXUyBDZXJ0aWZpY2F0ZSBNYW5hZ2VyXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgSUNlcnRpZmljYXRlIGV4dGVuZHMgSVJlc291cmNlIHtcbiAgLyoqXG4gICAqIFRoZSBjZXJ0aWZpY2F0ZSdzIEFSTlxuICAgKlxuICAgKiBAYXR0cmlidXRlXG4gICAqL1xuICByZWFkb25seSBjZXJ0aWZpY2F0ZUFybjogc3RyaW5nO1xufVxuXG4vKipcbiAqIFByb3BlcnRpZXMgZm9yIHlvdXIgY2VydGlmaWNhdGVcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBDZXJ0aWZpY2F0ZVByb3BzIHtcbiAgLyoqXG4gICAqIEZ1bGx5LXF1YWxpZmllZCBkb21haW4gbmFtZSB0byByZXF1ZXN0IGEgY2VydGlmaWNhdGUgZm9yLlxuICAgKlxuICAgKiBNYXkgY29udGFpbiB3aWxkY2FyZHMsIHN1Y2ggYXMgYGAqLmRvbWFpbi5jb21gYC5cbiAgICovXG4gIHJlYWRvbmx5IGRvbWFpbk5hbWU6IHN0cmluZztcblxuICAvKipcbiAgICogQWx0ZXJuYXRpdmUgZG9tYWluIG5hbWVzIG9uIHlvdXIgY2VydGlmaWNhdGUuXG4gICAqXG4gICAqIFVzZSB0aGlzIHRvIHJlZ2lzdGVyIGFsdGVybmF0aXZlIGRvbWFpbiBuYW1lcyB0aGF0IHJlcHJlc2VudCB0aGUgc2FtZSBzaXRlLlxuICAgKlxuICAgKiBAZGVmYXVsdCAtIE5vIGFkZGl0aW9uYWwgRlFETnMgd2lsbCBiZSBpbmNsdWRlZCBhcyBhbHRlcm5hdGl2ZSBkb21haW4gbmFtZXMuXG4gICAqL1xuICByZWFkb25seSBzdWJqZWN0QWx0ZXJuYXRpdmVOYW1lcz86IHN0cmluZ1tdO1xuXG4gIC8qKlxuICAgKiBXaGF0IHZhbGlkYXRpb24gZG9tYWluIHRvIHVzZSBmb3IgZXZlcnkgcmVxdWVzdGVkIGRvbWFpbi5cbiAgICpcbiAgICogSGFzIHRvIGJlIGEgc3VwZXJkb21haW4gb2YgdGhlIHJlcXVlc3RlZCBkb21haW4uXG4gICAqXG4gICAqIEBkZWZhdWx0IC0gQXBleCBkb21haW4gaXMgdXNlZCBmb3IgZXZlcnkgZG9tYWluIHRoYXQncyBub3Qgb3ZlcnJpZGRlbi5cbiAgICovXG4gIHJlYWRvbmx5IHZhbGlkYXRpb25Eb21haW5zPzoge1tkb21haW5OYW1lOiBzdHJpbmddOiBzdHJpbmd9O1xuXG4gIC8qKlxuICAgKiBWYWxpZGF0aW9uIG1ldGhvZCB1c2VkIHRvIGFzc2VydCBkb21haW4gb3duZXJzaGlwXG4gICAqXG4gICAqIEBkZWZhdWx0IFZhbGlkYXRpb25NZXRob2QuRU1BSUxcbiAgICovXG4gIHJlYWRvbmx5IHZhbGlkYXRpb25NZXRob2Q/OiBWYWxpZGF0aW9uTWV0aG9kO1xufVxuXG4vKipcbiAqIEEgY2VydGlmaWNhdGUgbWFuYWdlZCBieSBBV1MgQ2VydGlmaWNhdGUgTWFuYWdlclxuICpcbiAqIElNUE9SVEFOVDogaWYgeW91IGFyZSBjcmVhdGluZyBhIGNlcnRpZmljYXRlIGFzIHBhcnQgb2YgeW91ciBzdGFjaywgdGhlIHN0YWNrXG4gKiB3aWxsIG5vdCBjb21wbGV0ZSBjcmVhdGluZyB1bnRpbCB5b3UgcmVhZCBhbmQgZm9sbG93IHRoZSBpbnN0cnVjdGlvbnMgaW4gdGhlXG4gKiBlbWFpbCB0aGF0IHlvdSB3aWxsIHJlY2VpdmUuXG4gKlxuICogQUNNIHdpbGwgc2VuZCB2YWxpZGF0aW9uIGVtYWlscyB0byB0aGUgZm9sbG93aW5nIGFkZHJlc3NlczpcbiAqXG4gKiAgYWRtaW5AZG9tYWluLmNvbVxuICogIGFkbWluaXN0cmF0b3JAZG9tYWluLmNvbVxuICogIGhvc3RtYXN0ZXJAZG9tYWluLmNvbVxuICogIHBvc3RtYXN0ZXJAZG9tYWluLmNvbVxuICogIHdlYm1hc3RlckBkb21haW4uY29tXG4gKlxuICogRm9yIGV2ZXJ5IGRvbWFpbiB0aGF0IHlvdSByZWdpc3Rlci5cbiAqL1xuZXhwb3J0IGNsYXNzIENlcnRpZmljYXRlIGV4dGVuZHMgUmVzb3VyY2UgaW1wbGVtZW50cyBJQ2VydGlmaWNhdGUge1xuXG4gIC8qKlxuICAgKiBJbXBvcnQgYSBjZXJ0aWZpY2F0ZVxuICAgKi9cbiAgcHVibGljIHN0YXRpYyBmcm9tQ2VydGlmaWNhdGVBcm4oc2NvcGU6IENvbnN0cnVjdCwgaWQ6IHN0cmluZywgY2VydGlmaWNhdGVBcm46IHN0cmluZyk6IElDZXJ0aWZpY2F0ZSB7XG4gICAgY2xhc3MgSW1wb3J0IGV4dGVuZHMgUmVzb3VyY2UgaW1wbGVtZW50cyBJQ2VydGlmaWNhdGUge1xuICAgICAgcHVibGljIGNlcnRpZmljYXRlQXJuID0gY2VydGlmaWNhdGVBcm47XG4gICAgfVxuXG4gICAgcmV0dXJuIG5ldyBJbXBvcnQoc2NvcGUsIGlkKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBUaGUgY2VydGlmaWNhdGUncyBBUk5cbiAgICovXG4gIHB1YmxpYyByZWFkb25seSBjZXJ0aWZpY2F0ZUFybjogc3RyaW5nO1xuXG4gIGNvbnN0cnVjdG9yKHNjb3BlOiBDb25zdHJ1Y3QsIGlkOiBzdHJpbmcsIHByb3BzOiBDZXJ0aWZpY2F0ZVByb3BzKSB7XG4gICAgc3VwZXIoc2NvcGUsIGlkKTtcblxuICAgIGNvbnN0IGFsbERvbWFpbk5hbWVzID0gW3Byb3BzLmRvbWFpbk5hbWVdLmNvbmNhdChwcm9wcy5zdWJqZWN0QWx0ZXJuYXRpdmVOYW1lcyB8fCBbXSk7XG5cbiAgICBjb25zdCBjZXJ0ID0gbmV3IENmbkNlcnRpZmljYXRlKHRoaXMsICdSZXNvdXJjZScsIHtcbiAgICAgIGRvbWFpbk5hbWU6IHByb3BzLmRvbWFpbk5hbWUsXG4gICAgICBzdWJqZWN0QWx0ZXJuYXRpdmVOYW1lczogcHJvcHMuc3ViamVjdEFsdGVybmF0aXZlTmFtZXMsXG4gICAgICBkb21haW5WYWxpZGF0aW9uT3B0aW9uczogYWxsRG9tYWluTmFtZXMubWFwKGRvbWFpblZhbGlkYXRpb25PcHRpb24pLFxuICAgICAgdmFsaWRhdGlvbk1ldGhvZDogcHJvcHMudmFsaWRhdGlvbk1ldGhvZCxcbiAgICB9KTtcblxuICAgIHRoaXMuY2VydGlmaWNhdGVBcm4gPSBjZXJ0LnJlZjtcblxuICAgIC8qKlxuICAgICAqIFJldHVybiB0aGUgZG9tYWluIHZhbGlkYXRpb24gb3B0aW9ucyBmb3IgdGhlIGdpdmVuIGRvbWFpblxuICAgICAqXG4gICAgICogQ2xvc2VzIG92ZXIgcHJvcHMuXG4gICAgICovXG4gICAgZnVuY3Rpb24gZG9tYWluVmFsaWRhdGlvbk9wdGlvbihkb21haW5OYW1lOiBzdHJpbmcpOiBDZm5DZXJ0aWZpY2F0ZS5Eb21haW5WYWxpZGF0aW9uT3B0aW9uUHJvcGVydHkge1xuICAgICAgbGV0IHZhbGlkYXRpb25Eb21haW4gPSBwcm9wcy52YWxpZGF0aW9uRG9tYWlucyAmJiBwcm9wcy52YWxpZGF0aW9uRG9tYWluc1tkb21haW5OYW1lXTtcbiAgICAgIGlmICh2YWxpZGF0aW9uRG9tYWluID09PSB1bmRlZmluZWQpIHtcbiAgICAgICAgaWYgKFRva2VuLmlzVW5yZXNvbHZlZChkb21haW5OYW1lKSkge1xuICAgICAgICAgIHRocm93IG5ldyBFcnJvcignV2hlbiB1c2luZyBUb2tlbnMgZm9yIGRvbWFpbiBuYW1lcywgXFwndmFsaWRhdGlvbkRvbWFpbnNcXCcgbmVlZHMgdG8gYmUgc3VwcGxpZWQnKTtcbiAgICAgICAgfVxuICAgICAgICB2YWxpZGF0aW9uRG9tYWluID0gYXBleERvbWFpbihkb21haW5OYW1lKTtcbiAgICAgIH1cblxuICAgICAgcmV0dXJuIHsgZG9tYWluTmFtZSwgdmFsaWRhdGlvbkRvbWFpbiB9O1xuICAgIH1cbiAgfVxufVxuXG4vKipcbiAqIE1ldGhvZCB1c2VkIHRvIGFzc2VydCBvd25lcnNoaXAgb2YgdGhlIGRvbWFpblxuICovXG5leHBvcnQgZW51bSBWYWxpZGF0aW9uTWV0aG9kIHtcbiAgLyoqXG4gICAqIFNlbmQgZW1haWwgdG8gYSBudW1iZXIgb2YgZW1haWwgYWRkcmVzc2VzIGFzc29jaWF0ZWQgd2l0aCB0aGUgZG9tYWluXG4gICAqXG4gICAqIEBzZWUgaHR0cHM6Ly9kb2NzLmF3cy5hbWF6b24uY29tL2FjbS9sYXRlc3QvdXNlcmd1aWRlL2dzLWFjbS12YWxpZGF0ZS1lbWFpbC5odG1sXG4gICAqL1xuICBFTUFJTCA9ICdFTUFJTCcsXG5cbiAgLyoqXG4gICAqIFZhbGlkYXRlIG93bmVyc2hpcCBieSBhZGRpbmcgYXBwcm9wcmlhdGUgRE5TIHJlY29yZHNcbiAgICpcbiAgICogQHNlZSBodHRwczovL2RvY3MuYXdzLmFtYXpvbi5jb20vYWNtL2xhdGVzdC91c2VyZ3VpZGUvZ3MtYWNtLXZhbGlkYXRlLWRucy5odG1sXG4gICAqL1xuICBETlMgPSAnRE5TJyxcbn0iXX0=
+// eslint-disable-next-line max-len
+function renderDomainValidation(validation, domainNames) {
+    var _a, _b, _c;
+    const domainValidation = [];
+    switch (validation.method) {
+        case ValidationMethod.DNS:
+            for (const domainName of domainNames) {
+                const hostedZone = (_b = (_a = validation.props.hostedZones) === null || _a === void 0 ? void 0 : _a[domainName]) !== null && _b !== void 0 ? _b : validation.props.hostedZone;
+                if (hostedZone) {
+                    domainValidation.push({ domainName, hostedZoneId: hostedZone.hostedZoneId });
+                }
+            }
+            break;
+        case ValidationMethod.EMAIL:
+            for (const domainName of domainNames) {
+                const validationDomain = (_c = validation.props.validationDomains) === null || _c === void 0 ? void 0 : _c[domainName];
+                if (!validationDomain && core_1.Token.isUnresolved(domainName)) {
+                    throw new Error('When using Tokens for domain names, \'validationDomains\' needs to be supplied');
+                }
+                domainValidation.push({ domainName, validationDomain: validationDomain !== null && validationDomain !== void 0 ? validationDomain : util_1.apexDomain(domainName) });
+            }
+            break;
+        default:
+            throw new Error(`Unknown validation method ${validation.method}`);
+    }
+    return domainValidation.length !== 0 ? domainValidation : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"certificate.js","sourceRoot":"","sources":["certificate.ts"],"names":[],"mappings":"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","sourcesContent":["import * as route53 from '@aws-cdk/aws-route53';\nimport { Construct, IResource, Resource, Token } from '@aws-cdk/core';\nimport { CfnCertificate } from './certificatemanager.generated';\nimport { apexDomain } from './util';\n\n/**\n * Represents a certificate in AWS Certificate Manager\n */\nexport interface ICertificate extends IResource {\n  /**\n   * The certificate's ARN\n   *\n   * @attribute\n   */\n  readonly certificateArn: string;\n}\n\n/**\n * Properties for your certificate\n */\nexport interface CertificateProps {\n  /**\n   * Fully-qualified domain name to request a certificate for.\n   *\n   * May contain wildcards, such as ``*.domain.com``.\n   */\n  readonly domainName: string;\n\n  /**\n   * Alternative domain names on your certificate.\n   *\n   * Use this to register alternative domain names that represent the same site.\n   *\n   * @default - No additional FQDNs will be included as alternative domain names.\n   */\n  readonly subjectAlternativeNames?: string[];\n\n  /**\n   * What validation domain to use for every requested domain.\n   *\n   * Has to be a superdomain of the requested domain.\n   *\n   * @default - Apex domain is used for every domain that's not overridden.\n   * @deprecated use `validation` instead.\n   */\n  readonly validationDomains?: {[domainName: string]: string};\n\n  /**\n   * Validation method used to assert domain ownership\n   *\n   * @default ValidationMethod.EMAIL\n   * @deprecated use `validation` instead.\n   */\n  readonly validationMethod?: ValidationMethod;\n\n  /**\n   * How to validate this certifcate\n   *\n   * @default CertificateValidation.fromEmail()\n   */\n  readonly validation?: CertificateValidation;\n}\n\n/**\n * Properties for certificate validation\n */\nexport interface CertificationValidationProps {\n  /**\n   * Validation method\n   *\n   * @default ValidationMethod.EMAIL\n   */\n  readonly method?: ValidationMethod;\n\n  /**\n   * Hosted zone to use for DNS validation\n   *\n   * @default - use email validation\n   */\n  readonly hostedZone?: route53.IHostedZone;\n\n  /**\n   * A map of hosted zones to use for DNS validation\n   *\n   * @default - use `hostedZone`\n   */\n  readonly hostedZones?: { [domainName: string]: route53.IHostedZone };\n\n  /**\n   * Validation domains to use for email validation\n   *\n   * @default - Apex domain\n   */\n  readonly validationDomains?: { [domainName: string]: string };\n}\n\n/**\n * How to validate a certificate\n */\nexport class CertificateValidation {\n  /**\n   * Validate the certifcate with DNS\n   *\n   * IMPORTANT: If `hostedZone` is not specified, DNS records must be added\n   * manually and the stack will not complete creating until the records are\n   * added.\n   *\n   * @param hostedZone the hosted zone where DNS records must be created\n   */\n  public static fromDns(hostedZone?: route53.IHostedZone) {\n    return new CertificateValidation({\n      method: ValidationMethod.DNS,\n      hostedZone,\n    });\n  }\n\n  /**\n   * Validate the certifcate with automatically created DNS records in multiple\n   * Amazon Route 53 hosted zones.\n   *\n   * @param hostedZones a map of hosted zones where DNS records must be created\n   * for the domains in the certificate\n   */\n  public static fromDnsMultiZone(hostedZones: { [domainName: string]: route53.IHostedZone }) {\n    return new CertificateValidation({\n      method: ValidationMethod.DNS,\n      hostedZones,\n    });\n  }\n\n  /**\n   * Validate the certifcate with Email\n   *\n   * IMPORTANT: if you are creating a certificate as part of your stack, the stack\n   * will not complete creating until you read and follow the instructions in the\n   * email that you will receive.\n   *\n   * ACM will send validation emails to the following addresses:\n   *\n   *  admin@domain.com\n   *  administrator@domain.com\n   *  hostmaster@domain.com\n   *  postmaster@domain.com\n   *  webmaster@domain.com\n   *\n   * For every domain that you register.\n   *\n   * @param validationDomains a map of validation domains to use for domains in the certificate\n   */\n  public static fromEmail(validationDomains?: { [domainName: string]: string }) {\n    return new CertificateValidation({\n      method: ValidationMethod.EMAIL,\n      validationDomains,\n    });\n  }\n\n  /**\n   * The validation method\n   */\n  public readonly method: ValidationMethod;\n\n  /** @param props Certification validation properties */\n  private constructor(public readonly props: CertificationValidationProps) {\n    this.method = props.method ?? ValidationMethod.EMAIL;\n  }\n}\n\n/**\n * A certificate managed by AWS Certificate Manager\n */\nexport class Certificate extends Resource implements ICertificate {\n\n  /**\n   * Import a certificate\n   */\n  public static fromCertificateArn(scope: Construct, id: string, certificateArn: string): ICertificate {\n    class Import extends Resource implements ICertificate {\n      public certificateArn = certificateArn;\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * The certificate's ARN\n   */\n  public readonly certificateArn: string;\n\n  constructor(scope: Construct, id: string, props: CertificateProps) {\n    super(scope, id);\n\n    let validation: CertificateValidation;\n    if (props.validation) {\n      validation = props.validation;\n    } else { // Deprecated props\n      if (props.validationMethod === ValidationMethod.DNS) {\n        validation = CertificateValidation.fromDns();\n      } else {\n        validation = CertificateValidation.fromEmail(props.validationDomains);\n      }\n    }\n\n    const allDomainNames = [props.domainName].concat(props.subjectAlternativeNames || []);\n\n    const cert = new CfnCertificate(this, 'Resource', {\n      domainName: props.domainName,\n      subjectAlternativeNames: props.subjectAlternativeNames,\n      domainValidationOptions: renderDomainValidation(validation, allDomainNames),\n      validationMethod: validation.method,\n    });\n\n    this.certificateArn = cert.ref;\n  }\n}\n\n/**\n * Method used to assert ownership of the domain\n */\nexport enum ValidationMethod {\n  /**\n   * Send email to a number of email addresses associated with the domain\n   *\n   * @see https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-validate-email.html\n   */\n  EMAIL = 'EMAIL',\n\n  /**\n   * Validate ownership by adding appropriate DNS records\n   *\n   * @see https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-validate-dns.html\n   */\n  DNS = 'DNS',\n}\n\n// eslint-disable-next-line max-len\nfunction renderDomainValidation(validation: CertificateValidation, domainNames: string[]): CfnCertificate.DomainValidationOptionProperty[] | undefined {\n  const domainValidation: CfnCertificate.DomainValidationOptionProperty[] = [];\n\n  switch (validation.method) {\n    case ValidationMethod.DNS:\n      for (const domainName of domainNames) {\n        const hostedZone = validation.props.hostedZones?.[domainName] ?? validation.props.hostedZone;\n        if (hostedZone) {\n          domainValidation.push({ domainName, hostedZoneId: hostedZone.hostedZoneId });\n        }\n      }\n      break;\n    case ValidationMethod.EMAIL:\n      for (const domainName of domainNames) {\n        const validationDomain = validation.props.validationDomains?.[domainName];\n        if (!validationDomain && Token.isUnresolved(domainName)) {\n          throw new Error('When using Tokens for domain names, \\'validationDomains\\' needs to be supplied');\n        }\n        domainValidation.push({ domainName, validationDomain: validationDomain ?? apexDomain(domainName) });\n      }\n      break;\n    default:\n      throw new Error(`Unknown validation method ${validation.method}`);\n  }\n\n  return domainValidation.length !== 0 ? domainValidation : undefined;\n}\n"]}

lib/certificatemanager.generated.js

@@ -5,6 +5,6 @@ "use strict";
 // See: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-resource-specification.html
-// @cfn2ts:meta@ {"generated":"2020-07-09T12:50:10.497Z","fingerprint":"f/iInCwubzWej/7SG588h6nQngqaNond/d4kIQNT6mQ="}
+// @cfn2ts:meta@ {"generated":"2020-07-18T01:11:46.220Z","fingerprint":"f/iInCwubzWej/7SG588h6nQngqaNond/d4kIQNT6mQ="}
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CfnCertificate = void 0;
-// tslint:disable:max-line-length | This is generated code - line lengths are difficult to control
+/* eslint-disable max-len */ // This is generated code - line lengths are difficult to control
 const cdk = require("@aws-cdk/core");
@@ -218,2 +218,2 @@ const cfn_parse = require("@aws-cdk/core/lib/cfn-parse");
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"certificatemanager.generated.js","sourceRoot":"","sources":["certificatemanager.generated.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2012-2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// Generated from the AWS CloudFormation Resource Specification\n// See: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-resource-specification.html\n// @cfn2ts:meta@ {\"generated\":\"2020-07-09T12:50:10.497Z\",\"fingerprint\":\"f/iInCwubzWej/7SG588h6nQngqaNond/d4kIQNT6mQ=\"}\n\n// tslint:disable:max-line-length | This is generated code - line lengths are difficult to control\n\nimport * as cdk from '@aws-cdk/core';\nimport * as cfn_parse from '@aws-cdk/core/lib/cfn-parse';\n\n/**\n * Properties for defining a `AWS::CertificateManager::Certificate`\n *\n * @stability external\n * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html\n */\nexport interface CfnCertificateProps {\n\n    /**\n     * `AWS::CertificateManager::Certificate.DomainName`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-domainname\n     */\n    readonly domainName: string;\n\n    /**\n     * `AWS::CertificateManager::Certificate.CertificateAuthorityArn`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-certificateauthorityarn\n     */\n    readonly certificateAuthorityArn?: string;\n\n    /**\n     * `AWS::CertificateManager::Certificate.CertificateTransparencyLoggingPreference`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-certificatetransparencyloggingpreference\n     */\n    readonly certificateTransparencyLoggingPreference?: string;\n\n    /**\n     * `AWS::CertificateManager::Certificate.DomainValidationOptions`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-domainvalidationoptions\n     */\n    readonly domainValidationOptions?: Array<CfnCertificate.DomainValidationOptionProperty | cdk.IResolvable> | cdk.IResolvable;\n\n    /**\n     * `AWS::CertificateManager::Certificate.SubjectAlternativeNames`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-subjectalternativenames\n     */\n    readonly subjectAlternativeNames?: string[];\n\n    /**\n     * `AWS::CertificateManager::Certificate.Tags`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-tags\n     */\n    readonly tags?: cdk.CfnTag[];\n\n    /**\n     * `AWS::CertificateManager::Certificate.ValidationMethod`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-validationmethod\n     */\n    readonly validationMethod?: string;\n}\n\n/**\n * Determine whether the given properties match those of a `CfnCertificateProps`\n *\n * @param properties - the TypeScript properties of a `CfnCertificateProps`\n *\n * @returns the result of the validation.\n */\nfunction CfnCertificatePropsValidator(properties: any): cdk.ValidationResult {\n    if (!cdk.canInspect(properties)) { return cdk.VALIDATION_SUCCESS; }\n    const errors = new cdk.ValidationResults();\n    errors.collect(cdk.propertyValidator('certificateAuthorityArn', cdk.validateString)(properties.certificateAuthorityArn));\n    errors.collect(cdk.propertyValidator('certificateTransparencyLoggingPreference', cdk.validateString)(properties.certificateTransparencyLoggingPreference));\n    errors.collect(cdk.propertyValidator('domainName', cdk.requiredValidator)(properties.domainName));\n    errors.collect(cdk.propertyValidator('domainName', cdk.validateString)(properties.domainName));\n    errors.collect(cdk.propertyValidator('domainValidationOptions', cdk.listValidator(CfnCertificate_DomainValidationOptionPropertyValidator))(properties.domainValidationOptions));\n    errors.collect(cdk.propertyValidator('subjectAlternativeNames', cdk.listValidator(cdk.validateString))(properties.subjectAlternativeNames));\n    errors.collect(cdk.propertyValidator('tags', cdk.listValidator(cdk.validateCfnTag))(properties.tags));\n    errors.collect(cdk.propertyValidator('validationMethod', cdk.validateString)(properties.validationMethod));\n    return errors.wrap('supplied properties not correct for \"CfnCertificateProps\"');\n}\n\n/**\n * Renders the AWS CloudFormation properties of an `AWS::CertificateManager::Certificate` resource\n *\n * @param properties - the TypeScript properties of a `CfnCertificateProps`\n *\n * @returns the AWS CloudFormation properties of an `AWS::CertificateManager::Certificate` resource.\n */\n// @ts-ignore TS6133\nfunction cfnCertificatePropsToCloudFormation(properties: any): any {\n    if (!cdk.canInspect(properties)) { return properties; }\n    CfnCertificatePropsValidator(properties).assertSuccess();\n    return {\n      DomainName: cdk.stringToCloudFormation(properties.domainName),\n      CertificateAuthorityArn: cdk.stringToCloudFormation(properties.certificateAuthorityArn),\n      CertificateTransparencyLoggingPreference: cdk.stringToCloudFormation(properties.certificateTransparencyLoggingPreference),\n      DomainValidationOptions: cdk.listMapper(cfnCertificateDomainValidationOptionPropertyToCloudFormation)(properties.domainValidationOptions),\n      SubjectAlternativeNames: cdk.listMapper(cdk.stringToCloudFormation)(properties.subjectAlternativeNames),\n      Tags: cdk.listMapper(cdk.cfnTagToCloudFormation)(properties.tags),\n      ValidationMethod: cdk.stringToCloudFormation(properties.validationMethod),\n    };\n}\n\n// @ts-ignore TS6133\nfunction CfnCertificatePropsFromCloudFormation(properties: any): CfnCertificateProps {\n    properties = properties || {};\n    return {\n        domainName: cfn_parse.FromCloudFormation.getString(properties.DomainName),\n        certificateAuthorityArn: properties.CertificateAuthorityArn == null ? undefined : cfn_parse.FromCloudFormation.getString(properties.CertificateAuthorityArn),\n        certificateTransparencyLoggingPreference: properties.CertificateTransparencyLoggingPreference == null ? undefined : cfn_parse.FromCloudFormation.getString(properties.CertificateTransparencyLoggingPreference),\n        domainValidationOptions: cfn_parse.FromCloudFormation.getArray(properties.DomainValidationOptions, (prop1: any) => CfnCertificateDomainValidationOptionPropertyFromCloudFormation(prop1)),\n        subjectAlternativeNames: cfn_parse.FromCloudFormation.getStringArray(properties.SubjectAlternativeNames),\n        tags: cfn_parse.FromCloudFormation.getArray(properties.Tags, (prop1: any) => cfn_parse.FromCloudFormation.getCfnTag(prop1) as any),\n        validationMethod: properties.ValidationMethod == null ? undefined : cfn_parse.FromCloudFormation.getString(properties.ValidationMethod),\n    };\n}\n\n/**\n * A CloudFormation `AWS::CertificateManager::Certificate`\n *\n * @cloudformationResource AWS::CertificateManager::Certificate\n * @stability external\n * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html\n */\nexport class CfnCertificate extends cdk.CfnResource implements cdk.IInspectable {\n    /**\n     * The CloudFormation resource type name for this resource class.\n     */\n    public static readonly CFN_RESOURCE_TYPE_NAME = \"AWS::CertificateManager::Certificate\";\n\n    /**\n     * A factory method that creates a new instance of this class from an object\n     * containing the CloudFormation properties of this resource.\n     * Used in the @aws-cdk/cloudformation-include module.\n     *\n     * @experimental\n     */\n    public static fromCloudFormation(scope: cdk.Construct, id: string, resourceAttributes: any, options: cdk.FromCloudFormationOptions): CfnCertificate {\n        resourceAttributes = resourceAttributes || {};\n        const cfnParser = new cfn_parse.CfnParser({\n            finder: options.finder,\n        });\n        const resourceProperties = cfnParser.parseValue(resourceAttributes.Properties);\n        const props = CfnCertificatePropsFromCloudFormation(resourceProperties);\n        const ret = new CfnCertificate(scope, id, props);\n        const cfnOptions = ret.cfnOptions;\n        cfnOptions.creationPolicy = cfnParser.parseCreationPolicy(resourceAttributes.CreationPolicy);\n        cfnOptions.updatePolicy = cfnParser.parseUpdatePolicy(resourceAttributes.UpdatePolicy);\n        cfnOptions.deletionPolicy = cfnParser.parseDeletionPolicy(resourceAttributes.DeletionPolicy);\n        cfnOptions.updateReplacePolicy = cfnParser.parseDeletionPolicy(resourceAttributes.UpdateReplacePolicy);\n        cfnOptions.metadata = cfnParser.parseValue(resourceAttributes.Metadata);\n        // handle DependsOn\n        resourceAttributes.DependsOn = resourceAttributes.DependsOn ?? [];\n        const dependencies: string[] = Array.isArray(resourceAttributes.DependsOn) ? resourceAttributes.DependsOn : [resourceAttributes.DependsOn];\n        for (const dep of dependencies) {\n            const depResource = options.finder.findResource(dep);\n            if (!depResource) {\n                throw new Error(`Resource '${id}' depends on '${dep}' that doesn't exist`);\n            }\n            ret.node.addDependency(depResource);\n        }\n        // handle Condition\n        if (resourceAttributes.Condition) {\n            const condition = options.finder.findCondition(resourceAttributes.Condition);\n            if (!condition) {\n                throw new Error(`Resource '${id}' uses Condition '${resourceAttributes.Condition}' that doesn't exist`);\n            }\n            cfnOptions.condition = condition;\n        }\n        return ret;\n    }\n\n    /**\n     * `AWS::CertificateManager::Certificate.DomainName`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-domainname\n     */\n    public domainName: string;\n\n    /**\n     * `AWS::CertificateManager::Certificate.CertificateAuthorityArn`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-certificateauthorityarn\n     */\n    public certificateAuthorityArn: string | undefined;\n\n    /**\n     * `AWS::CertificateManager::Certificate.CertificateTransparencyLoggingPreference`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-certificatetransparencyloggingpreference\n     */\n    public certificateTransparencyLoggingPreference: string | undefined;\n\n    /**\n     * `AWS::CertificateManager::Certificate.DomainValidationOptions`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-domainvalidationoptions\n     */\n    public domainValidationOptions: Array<CfnCertificate.DomainValidationOptionProperty | cdk.IResolvable> | cdk.IResolvable | undefined;\n\n    /**\n     * `AWS::CertificateManager::Certificate.SubjectAlternativeNames`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-subjectalternativenames\n     */\n    public subjectAlternativeNames: string[] | undefined;\n\n    /**\n     * `AWS::CertificateManager::Certificate.Tags`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-tags\n     */\n    public readonly tags: cdk.TagManager;\n\n    /**\n     * `AWS::CertificateManager::Certificate.ValidationMethod`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-validationmethod\n     */\n    public validationMethod: string | undefined;\n\n    /**\n     * Create a new `AWS::CertificateManager::Certificate`.\n     *\n     * @param scope - scope in which this resource is defined\n     * @param id    - scoped id of the resource\n     * @param props - resource properties\n     */\n    constructor(scope: cdk.Construct, id: string, props: CfnCertificateProps) {\n        super(scope, id, { type: CfnCertificate.CFN_RESOURCE_TYPE_NAME, properties: props });\n        cdk.requireProperty(props, 'domainName', this);\n\n        this.domainName = props.domainName;\n        this.certificateAuthorityArn = props.certificateAuthorityArn;\n        this.certificateTransparencyLoggingPreference = props.certificateTransparencyLoggingPreference;\n        this.domainValidationOptions = props.domainValidationOptions;\n        this.subjectAlternativeNames = props.subjectAlternativeNames;\n        this.tags = new cdk.TagManager(cdk.TagType.STANDARD, \"AWS::CertificateManager::Certificate\", props.tags, { tagPropertyName: 'tags' });\n        this.validationMethod = props.validationMethod;\n    }\n\n    /**\n     * Examines the CloudFormation resource and discloses attributes.\n     *\n     * @param inspector - tree inspector to collect and process attributes\n     *\n     * @stability experimental\n     */\n    public inspect(inspector: cdk.TreeInspector) {\n        inspector.addAttribute(\"aws:cdk:cloudformation:type\", CfnCertificate.CFN_RESOURCE_TYPE_NAME);\n        inspector.addAttribute(\"aws:cdk:cloudformation:props\", this.cfnProperties);\n    }\n\n    protected get cfnProperties(): { [key: string]: any }  {\n        return {\n            domainName: this.domainName,\n            certificateAuthorityArn: this.certificateAuthorityArn,\n            certificateTransparencyLoggingPreference: this.certificateTransparencyLoggingPreference,\n            domainValidationOptions: this.domainValidationOptions,\n            subjectAlternativeNames: this.subjectAlternativeNames,\n            tags: this.tags.renderTags(),\n            validationMethod: this.validationMethod,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return cfnCertificatePropsToCloudFormation(props);\n    }\n}\n\nexport namespace CfnCertificate {\n    /**\n     * @stability external\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-certificatemanager-certificate-domainvalidationoption.html\n     */\n    export interface DomainValidationOptionProperty {\n        /**\n         * `CfnCertificate.DomainValidationOptionProperty.DomainName`\n         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-certificatemanager-certificate-domainvalidationoption.html#cfn-certificatemanager-certificate-domainvalidationoptions-domainname\n         */\n        readonly domainName: string;\n        /**\n         * `CfnCertificate.DomainValidationOptionProperty.HostedZoneId`\n         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-certificatemanager-certificate-domainvalidationoption.html#cfn-certificatemanager-certificate-domainvalidationoption-hostedzoneid\n         */\n        readonly hostedZoneId?: string;\n        /**\n         * `CfnCertificate.DomainValidationOptionProperty.ValidationDomain`\n         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-certificatemanager-certificate-domainvalidationoption.html#cfn-certificatemanager-certificate-domainvalidationoption-validationdomain\n         */\n        readonly validationDomain?: string;\n    }\n}\n\n/**\n * Determine whether the given properties match those of a `DomainValidationOptionProperty`\n *\n * @param properties - the TypeScript properties of a `DomainValidationOptionProperty`\n *\n * @returns the result of the validation.\n */\nfunction CfnCertificate_DomainValidationOptionPropertyValidator(properties: any): cdk.ValidationResult {\n    if (!cdk.canInspect(properties)) { return cdk.VALIDATION_SUCCESS; }\n    const errors = new cdk.ValidationResults();\n    errors.collect(cdk.propertyValidator('domainName', cdk.requiredValidator)(properties.domainName));\n    errors.collect(cdk.propertyValidator('domainName', cdk.validateString)(properties.domainName));\n    errors.collect(cdk.propertyValidator('hostedZoneId', cdk.validateString)(properties.hostedZoneId));\n    errors.collect(cdk.propertyValidator('validationDomain', cdk.validateString)(properties.validationDomain));\n    return errors.wrap('supplied properties not correct for \"DomainValidationOptionProperty\"');\n}\n\n/**\n * Renders the AWS CloudFormation properties of an `AWS::CertificateManager::Certificate.DomainValidationOption` resource\n *\n * @param properties - the TypeScript properties of a `DomainValidationOptionProperty`\n *\n * @returns the AWS CloudFormation properties of an `AWS::CertificateManager::Certificate.DomainValidationOption` resource.\n */\n// @ts-ignore TS6133\nfunction cfnCertificateDomainValidationOptionPropertyToCloudFormation(properties: any): any {\n    if (!cdk.canInspect(properties)) { return properties; }\n    CfnCertificate_DomainValidationOptionPropertyValidator(properties).assertSuccess();\n    return {\n      DomainName: cdk.stringToCloudFormation(properties.domainName),\n      HostedZoneId: cdk.stringToCloudFormation(properties.hostedZoneId),\n      ValidationDomain: cdk.stringToCloudFormation(properties.validationDomain),\n    };\n}\n\n// @ts-ignore TS6133\nfunction CfnCertificateDomainValidationOptionPropertyFromCloudFormation(properties: any): CfnCertificate.DomainValidationOptionProperty | cdk.IResolvable {\n    if (cdk.isResolvableObject(properties)) {\n        return properties;\n    }\n    properties = properties || {};\n    return {\n        domainName: cfn_parse.FromCloudFormation.getString(properties.DomainName),\n        hostedZoneId: properties.HostedZoneId == null ? undefined : cfn_parse.FromCloudFormation.getString(properties.HostedZoneId),\n        validationDomain: properties.ValidationDomain == null ? undefined : cfn_parse.FromCloudFormation.getString(properties.ValidationDomain),\n    };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"certificatemanager.generated.js","sourceRoot":"","sources":["certificatemanager.generated.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2012-2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// Generated from the AWS CloudFormation Resource Specification\n// See: docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-resource-specification.html\n// @cfn2ts:meta@ {\"generated\":\"2020-07-18T01:11:46.220Z\",\"fingerprint\":\"f/iInCwubzWej/7SG588h6nQngqaNond/d4kIQNT6mQ=\"}\n\n/* eslint-disable max-len */ // This is generated code - line lengths are difficult to control\n\nimport * as cdk from '@aws-cdk/core';\nimport * as cfn_parse from '@aws-cdk/core/lib/cfn-parse';\n\n/**\n * Properties for defining a `AWS::CertificateManager::Certificate`\n *\n * @stability external\n * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html\n */\nexport interface CfnCertificateProps {\n\n    /**\n     * `AWS::CertificateManager::Certificate.DomainName`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-domainname\n     */\n    readonly domainName: string;\n\n    /**\n     * `AWS::CertificateManager::Certificate.CertificateAuthorityArn`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-certificateauthorityarn\n     */\n    readonly certificateAuthorityArn?: string;\n\n    /**\n     * `AWS::CertificateManager::Certificate.CertificateTransparencyLoggingPreference`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-certificatetransparencyloggingpreference\n     */\n    readonly certificateTransparencyLoggingPreference?: string;\n\n    /**\n     * `AWS::CertificateManager::Certificate.DomainValidationOptions`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-domainvalidationoptions\n     */\n    readonly domainValidationOptions?: Array<CfnCertificate.DomainValidationOptionProperty | cdk.IResolvable> | cdk.IResolvable;\n\n    /**\n     * `AWS::CertificateManager::Certificate.SubjectAlternativeNames`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-subjectalternativenames\n     */\n    readonly subjectAlternativeNames?: string[];\n\n    /**\n     * `AWS::CertificateManager::Certificate.Tags`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-tags\n     */\n    readonly tags?: cdk.CfnTag[];\n\n    /**\n     * `AWS::CertificateManager::Certificate.ValidationMethod`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-validationmethod\n     */\n    readonly validationMethod?: string;\n}\n\n/**\n * Determine whether the given properties match those of a `CfnCertificateProps`\n *\n * @param properties - the TypeScript properties of a `CfnCertificateProps`\n *\n * @returns the result of the validation.\n */\nfunction CfnCertificatePropsValidator(properties: any): cdk.ValidationResult {\n    if (!cdk.canInspect(properties)) { return cdk.VALIDATION_SUCCESS; }\n    const errors = new cdk.ValidationResults();\n    errors.collect(cdk.propertyValidator('certificateAuthorityArn', cdk.validateString)(properties.certificateAuthorityArn));\n    errors.collect(cdk.propertyValidator('certificateTransparencyLoggingPreference', cdk.validateString)(properties.certificateTransparencyLoggingPreference));\n    errors.collect(cdk.propertyValidator('domainName', cdk.requiredValidator)(properties.domainName));\n    errors.collect(cdk.propertyValidator('domainName', cdk.validateString)(properties.domainName));\n    errors.collect(cdk.propertyValidator('domainValidationOptions', cdk.listValidator(CfnCertificate_DomainValidationOptionPropertyValidator))(properties.domainValidationOptions));\n    errors.collect(cdk.propertyValidator('subjectAlternativeNames', cdk.listValidator(cdk.validateString))(properties.subjectAlternativeNames));\n    errors.collect(cdk.propertyValidator('tags', cdk.listValidator(cdk.validateCfnTag))(properties.tags));\n    errors.collect(cdk.propertyValidator('validationMethod', cdk.validateString)(properties.validationMethod));\n    return errors.wrap('supplied properties not correct for \"CfnCertificateProps\"');\n}\n\n/**\n * Renders the AWS CloudFormation properties of an `AWS::CertificateManager::Certificate` resource\n *\n * @param properties - the TypeScript properties of a `CfnCertificateProps`\n *\n * @returns the AWS CloudFormation properties of an `AWS::CertificateManager::Certificate` resource.\n */\n// @ts-ignore TS6133\nfunction cfnCertificatePropsToCloudFormation(properties: any): any {\n    if (!cdk.canInspect(properties)) { return properties; }\n    CfnCertificatePropsValidator(properties).assertSuccess();\n    return {\n      DomainName: cdk.stringToCloudFormation(properties.domainName),\n      CertificateAuthorityArn: cdk.stringToCloudFormation(properties.certificateAuthorityArn),\n      CertificateTransparencyLoggingPreference: cdk.stringToCloudFormation(properties.certificateTransparencyLoggingPreference),\n      DomainValidationOptions: cdk.listMapper(cfnCertificateDomainValidationOptionPropertyToCloudFormation)(properties.domainValidationOptions),\n      SubjectAlternativeNames: cdk.listMapper(cdk.stringToCloudFormation)(properties.subjectAlternativeNames),\n      Tags: cdk.listMapper(cdk.cfnTagToCloudFormation)(properties.tags),\n      ValidationMethod: cdk.stringToCloudFormation(properties.validationMethod),\n    };\n}\n\n// @ts-ignore TS6133\nfunction CfnCertificatePropsFromCloudFormation(properties: any): CfnCertificateProps {\n    properties = properties || {};\n    return {\n        domainName: cfn_parse.FromCloudFormation.getString(properties.DomainName),\n        certificateAuthorityArn: properties.CertificateAuthorityArn == null ? undefined : cfn_parse.FromCloudFormation.getString(properties.CertificateAuthorityArn),\n        certificateTransparencyLoggingPreference: properties.CertificateTransparencyLoggingPreference == null ? undefined : cfn_parse.FromCloudFormation.getString(properties.CertificateTransparencyLoggingPreference),\n        domainValidationOptions: cfn_parse.FromCloudFormation.getArray(properties.DomainValidationOptions, (prop1: any) => CfnCertificateDomainValidationOptionPropertyFromCloudFormation(prop1)),\n        subjectAlternativeNames: cfn_parse.FromCloudFormation.getStringArray(properties.SubjectAlternativeNames),\n        tags: cfn_parse.FromCloudFormation.getArray(properties.Tags, (prop1: any) => cfn_parse.FromCloudFormation.getCfnTag(prop1) as any),\n        validationMethod: properties.ValidationMethod == null ? undefined : cfn_parse.FromCloudFormation.getString(properties.ValidationMethod),\n    };\n}\n\n/**\n * A CloudFormation `AWS::CertificateManager::Certificate`\n *\n * @cloudformationResource AWS::CertificateManager::Certificate\n * @stability external\n * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html\n */\nexport class CfnCertificate extends cdk.CfnResource implements cdk.IInspectable {\n    /**\n     * The CloudFormation resource type name for this resource class.\n     */\n    public static readonly CFN_RESOURCE_TYPE_NAME = \"AWS::CertificateManager::Certificate\";\n\n    /**\n     * A factory method that creates a new instance of this class from an object\n     * containing the CloudFormation properties of this resource.\n     * Used in the @aws-cdk/cloudformation-include module.\n     *\n     * @experimental\n     */\n    public static fromCloudFormation(scope: cdk.Construct, id: string, resourceAttributes: any, options: cdk.FromCloudFormationOptions): CfnCertificate {\n        resourceAttributes = resourceAttributes || {};\n        const cfnParser = new cfn_parse.CfnParser({\n            finder: options.finder,\n        });\n        const resourceProperties = cfnParser.parseValue(resourceAttributes.Properties);\n        const props = CfnCertificatePropsFromCloudFormation(resourceProperties);\n        const ret = new CfnCertificate(scope, id, props);\n        const cfnOptions = ret.cfnOptions;\n        cfnOptions.creationPolicy = cfnParser.parseCreationPolicy(resourceAttributes.CreationPolicy);\n        cfnOptions.updatePolicy = cfnParser.parseUpdatePolicy(resourceAttributes.UpdatePolicy);\n        cfnOptions.deletionPolicy = cfnParser.parseDeletionPolicy(resourceAttributes.DeletionPolicy);\n        cfnOptions.updateReplacePolicy = cfnParser.parseDeletionPolicy(resourceAttributes.UpdateReplacePolicy);\n        cfnOptions.metadata = cfnParser.parseValue(resourceAttributes.Metadata);\n        // handle DependsOn\n        resourceAttributes.DependsOn = resourceAttributes.DependsOn ?? [];\n        const dependencies: string[] = Array.isArray(resourceAttributes.DependsOn) ? resourceAttributes.DependsOn : [resourceAttributes.DependsOn];\n        for (const dep of dependencies) {\n            const depResource = options.finder.findResource(dep);\n            if (!depResource) {\n                throw new Error(`Resource '${id}' depends on '${dep}' that doesn't exist`);\n            }\n            ret.node.addDependency(depResource);\n        }\n        // handle Condition\n        if (resourceAttributes.Condition) {\n            const condition = options.finder.findCondition(resourceAttributes.Condition);\n            if (!condition) {\n                throw new Error(`Resource '${id}' uses Condition '${resourceAttributes.Condition}' that doesn't exist`);\n            }\n            cfnOptions.condition = condition;\n        }\n        return ret;\n    }\n\n    /**\n     * `AWS::CertificateManager::Certificate.DomainName`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-domainname\n     */\n    public domainName: string;\n\n    /**\n     * `AWS::CertificateManager::Certificate.CertificateAuthorityArn`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-certificateauthorityarn\n     */\n    public certificateAuthorityArn: string | undefined;\n\n    /**\n     * `AWS::CertificateManager::Certificate.CertificateTransparencyLoggingPreference`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-certificatetransparencyloggingpreference\n     */\n    public certificateTransparencyLoggingPreference: string | undefined;\n\n    /**\n     * `AWS::CertificateManager::Certificate.DomainValidationOptions`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-domainvalidationoptions\n     */\n    public domainValidationOptions: Array<CfnCertificate.DomainValidationOptionProperty | cdk.IResolvable> | cdk.IResolvable | undefined;\n\n    /**\n     * `AWS::CertificateManager::Certificate.SubjectAlternativeNames`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-subjectalternativenames\n     */\n    public subjectAlternativeNames: string[] | undefined;\n\n    /**\n     * `AWS::CertificateManager::Certificate.Tags`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-tags\n     */\n    public readonly tags: cdk.TagManager;\n\n    /**\n     * `AWS::CertificateManager::Certificate.ValidationMethod`\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-certificatemanager-certificate.html#cfn-certificatemanager-certificate-validationmethod\n     */\n    public validationMethod: string | undefined;\n\n    /**\n     * Create a new `AWS::CertificateManager::Certificate`.\n     *\n     * @param scope - scope in which this resource is defined\n     * @param id    - scoped id of the resource\n     * @param props - resource properties\n     */\n    constructor(scope: cdk.Construct, id: string, props: CfnCertificateProps) {\n        super(scope, id, { type: CfnCertificate.CFN_RESOURCE_TYPE_NAME, properties: props });\n        cdk.requireProperty(props, 'domainName', this);\n\n        this.domainName = props.domainName;\n        this.certificateAuthorityArn = props.certificateAuthorityArn;\n        this.certificateTransparencyLoggingPreference = props.certificateTransparencyLoggingPreference;\n        this.domainValidationOptions = props.domainValidationOptions;\n        this.subjectAlternativeNames = props.subjectAlternativeNames;\n        this.tags = new cdk.TagManager(cdk.TagType.STANDARD, \"AWS::CertificateManager::Certificate\", props.tags, { tagPropertyName: 'tags' });\n        this.validationMethod = props.validationMethod;\n    }\n\n    /**\n     * Examines the CloudFormation resource and discloses attributes.\n     *\n     * @param inspector - tree inspector to collect and process attributes\n     *\n     * @stability experimental\n     */\n    public inspect(inspector: cdk.TreeInspector) {\n        inspector.addAttribute(\"aws:cdk:cloudformation:type\", CfnCertificate.CFN_RESOURCE_TYPE_NAME);\n        inspector.addAttribute(\"aws:cdk:cloudformation:props\", this.cfnProperties);\n    }\n\n    protected get cfnProperties(): { [key: string]: any }  {\n        return {\n            domainName: this.domainName,\n            certificateAuthorityArn: this.certificateAuthorityArn,\n            certificateTransparencyLoggingPreference: this.certificateTransparencyLoggingPreference,\n            domainValidationOptions: this.domainValidationOptions,\n            subjectAlternativeNames: this.subjectAlternativeNames,\n            tags: this.tags.renderTags(),\n            validationMethod: this.validationMethod,\n        };\n    }\n    protected renderProperties(props: {[key: string]: any}): { [key: string]: any }  {\n        return cfnCertificatePropsToCloudFormation(props);\n    }\n}\n\nexport namespace CfnCertificate {\n    /**\n     * @stability external\n     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-certificatemanager-certificate-domainvalidationoption.html\n     */\n    export interface DomainValidationOptionProperty {\n        /**\n         * `CfnCertificate.DomainValidationOptionProperty.DomainName`\n         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-certificatemanager-certificate-domainvalidationoption.html#cfn-certificatemanager-certificate-domainvalidationoptions-domainname\n         */\n        readonly domainName: string;\n        /**\n         * `CfnCertificate.DomainValidationOptionProperty.HostedZoneId`\n         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-certificatemanager-certificate-domainvalidationoption.html#cfn-certificatemanager-certificate-domainvalidationoption-hostedzoneid\n         */\n        readonly hostedZoneId?: string;\n        /**\n         * `CfnCertificate.DomainValidationOptionProperty.ValidationDomain`\n         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-certificatemanager-certificate-domainvalidationoption.html#cfn-certificatemanager-certificate-domainvalidationoption-validationdomain\n         */\n        readonly validationDomain?: string;\n    }\n}\n\n/**\n * Determine whether the given properties match those of a `DomainValidationOptionProperty`\n *\n * @param properties - the TypeScript properties of a `DomainValidationOptionProperty`\n *\n * @returns the result of the validation.\n */\nfunction CfnCertificate_DomainValidationOptionPropertyValidator(properties: any): cdk.ValidationResult {\n    if (!cdk.canInspect(properties)) { return cdk.VALIDATION_SUCCESS; }\n    const errors = new cdk.ValidationResults();\n    errors.collect(cdk.propertyValidator('domainName', cdk.requiredValidator)(properties.domainName));\n    errors.collect(cdk.propertyValidator('domainName', cdk.validateString)(properties.domainName));\n    errors.collect(cdk.propertyValidator('hostedZoneId', cdk.validateString)(properties.hostedZoneId));\n    errors.collect(cdk.propertyValidator('validationDomain', cdk.validateString)(properties.validationDomain));\n    return errors.wrap('supplied properties not correct for \"DomainValidationOptionProperty\"');\n}\n\n/**\n * Renders the AWS CloudFormation properties of an `AWS::CertificateManager::Certificate.DomainValidationOption` resource\n *\n * @param properties - the TypeScript properties of a `DomainValidationOptionProperty`\n *\n * @returns the AWS CloudFormation properties of an `AWS::CertificateManager::Certificate.DomainValidationOption` resource.\n */\n// @ts-ignore TS6133\nfunction cfnCertificateDomainValidationOptionPropertyToCloudFormation(properties: any): any {\n    if (!cdk.canInspect(properties)) { return properties; }\n    CfnCertificate_DomainValidationOptionPropertyValidator(properties).assertSuccess();\n    return {\n      DomainName: cdk.stringToCloudFormation(properties.domainName),\n      HostedZoneId: cdk.stringToCloudFormation(properties.hostedZoneId),\n      ValidationDomain: cdk.stringToCloudFormation(properties.validationDomain),\n    };\n}\n\n// @ts-ignore TS6133\nfunction CfnCertificateDomainValidationOptionPropertyFromCloudFormation(properties: any): CfnCertificate.DomainValidationOptionProperty | cdk.IResolvable {\n    if (cdk.isResolvableObject(properties)) {\n        return properties;\n    }\n    properties = properties || {};\n    return {\n        domainName: cfn_parse.FromCloudFormation.getString(properties.DomainName),\n        hostedZoneId: properties.HostedZoneId == null ? undefined : cfn_parse.FromCloudFormation.getString(properties.HostedZoneId),\n        validationDomain: properties.ValidationDomain == null ? undefined : cfn_parse.FromCloudFormation.getString(properties.ValidationDomain),\n    };\n}\n"]}

package.json

 {
   "name": "@aws-cdk/aws-certificatemanager",
-  "version": "1.51.0",
+  "version": "1.52.0",
   "description": "The CDK Construct Library for AWS::CertificateManager",
@@ -65,14 +65,14 @@ "main": "lib/index.js",
   "devDependencies": {
-    "@aws-cdk/assert": "1.51.0",
+    "@aws-cdk/assert": "1.52.0",
     "@types/nodeunit": "^0.0.31",
-    "cdk-build-tools": "1.51.0",
-    "cfn2ts": "1.51.0",
+    "cdk-build-tools": "1.52.0",
+    "cfn2ts": "1.52.0",
     "nodeunit": "^0.11.3",
-    "pkglint": "1.51.0"
+    "pkglint": "1.52.0"
   },
   "dependencies": {
-    "@aws-cdk/aws-iam": "1.51.0",
-    "@aws-cdk/aws-lambda": "1.51.0",
-    "@aws-cdk/aws-route53": "1.51.0",
-    "@aws-cdk/core": "1.51.0",
+    "@aws-cdk/aws-iam": "1.52.0",
+    "@aws-cdk/aws-lambda": "1.52.0",
+    "@aws-cdk/aws-route53": "1.52.0",
+    "@aws-cdk/core": "1.52.0",
     "constructs": "^3.0.2"
@@ -82,6 +82,6 @@ },
   "peerDependencies": {
-    "@aws-cdk/aws-iam": "1.51.0",
-    "@aws-cdk/aws-lambda": "1.51.0",
-    "@aws-cdk/aws-route53": "1.51.0",
-    "@aws-cdk/core": "1.51.0",
+    "@aws-cdk/aws-iam": "1.52.0",
+    "@aws-cdk/aws-lambda": "1.52.0",
+    "@aws-cdk/aws-route53": "1.52.0",
+    "@aws-cdk/core": "1.52.0",
     "constructs": "^3.0.2"
@@ -88,0 +88,0 @@ },

README.md

@@ -23,10 +23,6 @@ ## AWS Certificate Manager Construct Library
 
-Because of this wait time, it's better to provision your certificates
-either in a separate stack from your main service, or provision them
-manually and import them into your CDK application.
+Because of this wait time, when using manual validation methods, it's better
+to provision your certificates either in a separate stack from your main
+service, or provision them manually and import them into your CDK application.
 
-The CDK also provides a custom resource which can be used for automatic
-validation if the DNS records for the domain are managed through Route53 (see
-below).
-
 ### Email validation
@@ -43,22 +39,46 @@
 
-DNS-validated certificates are validated by configuring appropriate DNS
-records for your domain.
+If Amazon Route 53 is your DNS provider for the requested domain, the DNS record can be
+created automatically:
 
-See [Validate with DNS](https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-validate-dns.html)
+```ts
+new Certificate(this, 'Certificate', {
+  domainName: 'hello.example.com',
+  validation: CertificateValidation.fromDns(myHostedZone), // Route 53 hosted zone
+});
+```
+
+Otherwise DNS records must be added manually and the stack will not complete
+creating until the records are added.
+
+```ts
+new Certificate(this, 'Certificate', {
+  domainName: 'hello.example.com',
+  validation: CertificateValidation.fromDns(), // Records must be added manually
+});
+```
+
+See also [Validate with DNS](https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-validate-dns.html)
 in the AWS Certificate Manager User Guide.
 
-### Automatic DNS-validated certificates using Route53
+When working with multiple domains, use the `CertificateValidation.fromDnsMultiZone()`:
 
-The `DnsValidatedCertificateRequest` class provides a Custom Resource by which
-you can request a TLS certificate from AWS Certificate Manager that is
-automatically validated using a cryptographically secure DNS record. For this to
-work, there must be a Route 53 public zone that is responsible for serving
-records under the Domain Name of the requested certificate. For example, if you
-request a certificate for `www.example.com`, there must be a Route 53 public
-zone `example.com` that provides authoritative records for the domain.
+[multiple domains DNS validation](test/example.dns.lit.ts)
 
-Example:
+Use the `DnsValidatedCertificate` construct for cross-region certificate creation:
 
-[request a validated certificate example](test/example.dns-validated-request.lit.ts)
+```ts
+new DnsValidatedCertificate(this, 'CrossRegionCertificate', {
+  domainName: 'hello.example.com',
+  hostedZone: myHostedZone,
+  region: 'us-east-1',
+});
+```
 
+This is useful when deploying a stack in a region other than `us-east-1` with a
+certificate for a CloudFront distribution.
+
+If cross-region is not needed, the recommended solution is to use the
+`Certificate` construct which uses a native CloudFormation implementation.
+
+
 ### Importing
@@ -76,2 +96,2 @@
 To share the certificate between stacks in the same CDK application, simply
-pass the `Certificate` object between the stacks.
+pass the `Certificate` object between the stacks.

test/test.certificate.d.ts

@@ -9,3 +9,7 @@ import { Test } from 'nodeunit';
     'validationdomains can be given for a Token'(test: Test): void;
+    'CertificateValidation.fromEmail'(test: Test): void;
+    'CertificateValidation.fromDns'(test: Test): void;
+    'CertificateValidation.fromDns with hosted zone'(test: Test): void;
+    'CertificateValidation.fromDnsMultiZone'(test: Test): void;
 };
 export = _default;

test/test.certificate.js

 "use strict";
 const assert_1 = require("@aws-cdk/assert");
+const route53 = require("@aws-cdk/aws-route53");
 const core_1 = require("@aws-cdk/core");
@@ -85,3 +86,109 @@ const lib_1 = require("../lib");
     },
+    'CertificateValidation.fromEmail'(test) {
+        const stack = new core_1.Stack();
+        new lib_1.Certificate(stack, 'Certificate', {
+            domainName: 'test.example.com',
+            subjectAlternativeNames: ['extra.example.com'],
+            validation: lib_1.CertificateValidation.fromEmail({
+                'test.example.com': 'example.com',
+            }),
+        });
+        assert_1.expect(stack).to(assert_1.haveResource('AWS::CertificateManager::Certificate', {
+            DomainName: 'test.example.com',
+            SubjectAlternativeNames: ['extra.example.com'],
+            DomainValidationOptions: [
+                {
+                    DomainName: 'test.example.com',
+                    ValidationDomain: 'example.com',
+                },
+                {
+                    DomainName: 'extra.example.com',
+                    ValidationDomain: 'example.com',
+                },
+            ],
+            ValidationMethod: 'EMAIL',
+        }));
+        test.done();
+    },
+    'CertificateValidation.fromDns'(test) {
+        const stack = new core_1.Stack();
+        new lib_1.Certificate(stack, 'Certificate', {
+            domainName: 'test.example.com',
+            subjectAlternativeNames: ['extra.example.com'],
+            validation: lib_1.CertificateValidation.fromDns(),
+        });
+        assert_1.expect(stack).to(assert_1.haveResource('AWS::CertificateManager::Certificate', {
+            DomainName: 'test.example.com',
+            SubjectAlternativeNames: ['extra.example.com'],
+            ValidationMethod: 'DNS',
+        }));
+        test.done();
+    },
+    'CertificateValidation.fromDns with hosted zone'(test) {
+        const stack = new core_1.Stack();
+        const exampleCom = new route53.HostedZone(stack, 'ExampleCom', {
+            zoneName: 'example.com',
+        });
+        new lib_1.Certificate(stack, 'Certificate', {
+            domainName: 'test.example.com',
+            validation: lib_1.CertificateValidation.fromDns(exampleCom),
+        });
+        assert_1.expect(stack).to(assert_1.haveResource('AWS::CertificateManager::Certificate', {
+            DomainName: 'test.example.com',
+            DomainValidationOptions: [
+                {
+                    DomainName: 'test.example.com',
+                    HostedZoneId: {
+                        Ref: 'ExampleCom20E1324B',
+                    },
+                },
+            ],
+            ValidationMethod: 'DNS',
+        }));
+        test.done();
+    },
+    'CertificateValidation.fromDnsMultiZone'(test) {
+        const stack = new core_1.Stack();
+        const exampleCom = new route53.HostedZone(stack, 'ExampleCom', {
+            zoneName: 'example.com',
+        });
+        const exampleNet = new route53.HostedZone(stack, 'ExampleNet', {
+            zoneName: 'example.com',
+        });
+        new lib_1.Certificate(stack, 'Certificate', {
+            domainName: 'test.example.com',
+            subjectAlternativeNames: ['cool.example.com', 'test.example.net'],
+            validation: lib_1.CertificateValidation.fromDnsMultiZone({
+                'test.example.com': exampleCom,
+                'cool.example.com': exampleCom,
+                'test.example.net': exampleNet,
+            }),
+        });
+        assert_1.expect(stack).to(assert_1.haveResource('AWS::CertificateManager::Certificate', {
+            DomainName: 'test.example.com',
+            DomainValidationOptions: [
+                {
+                    DomainName: 'test.example.com',
+                    HostedZoneId: {
+                        Ref: 'ExampleCom20E1324B',
+                    },
+                },
+                {
+                    DomainName: 'cool.example.com',
+                    HostedZoneId: {
+                        Ref: 'ExampleCom20E1324B',
+                    },
+                },
+                {
+                    DomainName: 'test.example.net',
+                    HostedZoneId: {
+                        Ref: 'ExampleNetF7CA40C9',
+                    },
+                },
+            ],
+            ValidationMethod: 'DNS',
+        }));
+        test.done();
+    },
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC5jZXJ0aWZpY2F0ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInRlc3QuY2VydGlmaWNhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLDRDQUF1RDtBQUN2RCx3Q0FBNEM7QUFFNUMsZ0NBQXVEO0FBRXZELGlCQUFTO0lBQ1Asa0NBQWtDLENBQUMsSUFBVTtRQUMzQyxNQUFNLEtBQUssR0FBRyxJQUFJLFlBQUssRUFBRSxDQUFDO1FBRTFCLElBQUksaUJBQVcsQ0FBQyxLQUFLLEVBQUUsYUFBYSxFQUFFO1lBQ3BDLFVBQVUsRUFBRSxrQkFBa0I7U0FDL0IsQ0FBQyxDQUFDO1FBRUgsZUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsQ0FBQyxxQkFBWSxDQUFDLHNDQUFzQyxFQUFFO1lBQ3BFLFVBQVUsRUFBRSxrQkFBa0I7WUFDOUIsdUJBQXVCLEVBQUUsQ0FBQztvQkFDeEIsVUFBVSxFQUFFLGtCQUFrQjtvQkFDOUIsZ0JBQWdCLEVBQUUsYUFBYTtpQkFDaEMsQ0FBQztTQUNILENBQUMsQ0FBQyxDQUFDO1FBRUosSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ2QsQ0FBQztJQUVELHFDQUFxQyxDQUFDLElBQVU7UUFDOUMsTUFBTSxLQUFLLEdBQUcsSUFBSSxZQUFLLEVBQUUsQ0FBQztRQUUxQixJQUFJLGlCQUFXLENBQUMsS0FBSyxFQUFFLGFBQWEsRUFBRTtZQUNwQyxVQUFVLEVBQUUsa0JBQWtCO1lBQzlCLGlCQUFpQixFQUFFO2dCQUNqQixrQkFBa0IsRUFBRSxrQkFBa0I7YUFDdkM7U0FDRixDQUFDLENBQUM7UUFFSCxlQUFNLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxDQUFDLHFCQUFZLENBQUMsc0NBQXNDLEVBQUU7WUFDcEUsdUJBQXVCLEVBQUUsQ0FBQztvQkFDeEIsVUFBVSxFQUFFLGtCQUFrQjtvQkFDOUIsZ0JBQWdCLEVBQUUsa0JBQWtCO2lCQUNyQyxDQUFDO1NBQ0gsQ0FBQyxDQUFDLENBQUM7UUFFSixJQUFJLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDZCxDQUFDO0lBRUQsbUJBQW1CLENBQUMsSUFBVTtRQUM1QixRQUFRO1FBQ1IsTUFBTSxLQUFLLEdBQUcsSUFBSSxZQUFLLEVBQUUsQ0FBQztRQUUxQixPQUFPO1FBQ1AsTUFBTSxDQUFDLEdBQUcsaUJBQVcsQ0FBQyxrQkFBa0IsQ0FBQyxLQUFLLEVBQUUsVUFBVSxFQUFFLFVBQVUsQ0FBQyxDQUFDO1FBRXhFLE9BQU87UUFDUCxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxjQUFjLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFDN0MsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ2QsQ0FBQztJQUVELGlDQUFpQyxDQUFDLElBQVU7UUFDMUMsTUFBTSxLQUFLLEdBQUcsSUFBSSxZQUFLLEVBQUUsQ0FBQztRQUUxQixJQUFJLGlCQUFXLENBQUMsS0FBSyxFQUFFLGFBQWEsRUFBRTtZQUNwQyxVQUFVLEVBQUUsa0JBQWtCO1lBQzlCLGdCQUFnQixFQUFFLHNCQUFnQixDQUFDLEdBQUc7U0FDdkMsQ0FBQyxDQUFDO1FBRUgsZUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsQ0FBQyxxQkFBWSxDQUFDLHNDQUFzQyxFQUFFO1lBQ3BFLFVBQVUsRUFBRSxrQkFBa0I7WUFDOUIsZ0JBQWdCLEVBQUUsS0FBSztTQUN4QixDQUFDLENBQUMsQ0FBQztRQUVKLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUNkLENBQUM7SUFFRCw2REFBNkQsQ0FBQyxJQUFVO1FBQ3RFLE1BQU0sS0FBSyxHQUFHLElBQUksWUFBSyxFQUFFLENBQUM7UUFFMUIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLEVBQUU7WUFDZixNQUFNLFVBQVUsR0FBRyxXQUFJLENBQUMsV0FBVyxDQUFDLEVBQUUsT0FBTyxFQUFFLEdBQUcsRUFBRSxDQUFDLGFBQWEsRUFBRSxDQUFDLENBQUM7WUFDdEUsSUFBSSxpQkFBVyxDQUFDLEtBQUssRUFBRSxhQUFhLEVBQUU7Z0JBQ3BDLFVBQVU7YUFDWCxDQUFDLENBQUM7UUFDTCxDQUFDLEVBQUUsMENBQTBDLENBQUMsQ0FBQztRQUUvQyxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDZCxDQUFDO0lBRUQsNENBQTRDLENBQUMsSUFBVTtRQUNyRCxNQUFNLEtBQUssR0FBRyxJQUFJLFlBQUssRUFBRSxDQUFDO1FBRTFCLE1BQU0sVUFBVSxHQUFHLFdBQUksQ0FBQyxXQUFXLENBQUMsRUFBRSxPQUFPLEVBQUUsR0FBRyxFQUFFLENBQUMsZ0JBQWdCLEVBQUUsQ0FBQyxDQUFDO1FBQ3pFLElBQUksaUJBQVcsQ0FBQyxLQUFLLEVBQUUsYUFBYSxFQUFFO1lBQ3BDLFVBQVU7WUFDVixpQkFBaUIsRUFBRTtnQkFDakIsQ0FBQyxVQUFVLENBQUMsRUFBRSxhQUFhO2FBQzVCO1NBQ0YsQ0FBQyxDQUFDO1FBRUgsZUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsQ0FBQyxxQkFBWSxDQUFDLHNDQUFzQyxFQUFFO1lBQ3BFLFVBQVUsRUFBRSxnQkFBZ0I7WUFDNUIsdUJBQXVCLEVBQUUsQ0FBQztvQkFDeEIsVUFBVSxFQUFFLGdCQUFnQjtvQkFDNUIsZ0JBQWdCLEVBQUUsYUFBYTtpQkFDaEMsQ0FBQztTQUNILENBQUMsQ0FBQyxDQUFDO1FBRUosSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ2QsQ0FBQztDQUNGLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBleHBlY3QsIGhhdmVSZXNvdXJjZSB9IGZyb20gJ0Bhd3MtY2RrL2Fzc2VydCc7XG5pbXBvcnQgeyBMYXp5LCBTdGFjayB9IGZyb20gJ0Bhd3MtY2RrL2NvcmUnO1xuaW1wb3J0IHsgVGVzdCB9IGZyb20gJ25vZGV1bml0JztcbmltcG9ydCB7IENlcnRpZmljYXRlLCBWYWxpZGF0aW9uTWV0aG9kIH0gZnJvbSAnLi4vbGliJztcblxuZXhwb3J0ID0ge1xuICAnYXBleCBkb21haW4gc2VsZWN0aW9uIGJ5IGRlZmF1bHQnKHRlc3Q6IFRlc3QpIHtcbiAgICBjb25zdCBzdGFjayA9IG5ldyBTdGFjaygpO1xuXG4gICAgbmV3IENlcnRpZmljYXRlKHN0YWNrLCAnQ2VydGlmaWNhdGUnLCB7XG4gICAgICBkb21haW5OYW1lOiAndGVzdC5leGFtcGxlLmNvbScsXG4gICAgfSk7XG5cbiAgICBleHBlY3Qoc3RhY2spLnRvKGhhdmVSZXNvdXJjZSgnQVdTOjpDZXJ0aWZpY2F0ZU1hbmFnZXI6OkNlcnRpZmljYXRlJywge1xuICAgICAgRG9tYWluTmFtZTogJ3Rlc3QuZXhhbXBsZS5jb20nLFxuICAgICAgRG9tYWluVmFsaWRhdGlvbk9wdGlvbnM6IFt7XG4gICAgICAgIERvbWFpbk5hbWU6ICd0ZXN0LmV4YW1wbGUuY29tJyxcbiAgICAgICAgVmFsaWRhdGlvbkRvbWFpbjogJ2V4YW1wbGUuY29tJyxcbiAgICAgIH1dLFxuICAgIH0pKTtcblxuICAgIHRlc3QuZG9uZSgpO1xuICB9LFxuXG4gICd2YWxpZGF0aW9uIGRvbWFpbiBjYW4gYmUgb3ZlcnJpZGRlbicodGVzdDogVGVzdCkge1xuICAgIGNvbnN0IHN0YWNrID0gbmV3IFN0YWNrKCk7XG5cbiAgICBuZXcgQ2VydGlmaWNhdGUoc3RhY2ssICdDZXJ0aWZpY2F0ZScsIHtcbiAgICAgIGRvbWFpbk5hbWU6ICd0ZXN0LmV4YW1wbGUuY29tJyxcbiAgICAgIHZhbGlkYXRpb25Eb21haW5zOiB7XG4gICAgICAgICd0ZXN0LmV4YW1wbGUuY29tJzogJ3Rlc3QuZXhhbXBsZS5jb20nLFxuICAgICAgfSxcbiAgICB9KTtcblxuICAgIGV4cGVjdChzdGFjaykudG8oaGF2ZVJlc291cmNlKCdBV1M6OkNlcnRpZmljYXRlTWFuYWdlcjo6Q2VydGlmaWNhdGUnLCB7XG4gICAgICBEb21haW5WYWxpZGF0aW9uT3B0aW9uczogW3tcbiAgICAgICAgRG9tYWluTmFtZTogJ3Rlc3QuZXhhbXBsZS5jb20nLFxuICAgICAgICBWYWxpZGF0aW9uRG9tYWluOiAndGVzdC5leGFtcGxlLmNvbScsXG4gICAgICB9XSxcbiAgICB9KSk7XG5cbiAgICB0ZXN0LmRvbmUoKTtcbiAgfSxcblxuICAnZXhwb3J0IGFuZCBpbXBvcnQnKHRlc3Q6IFRlc3QpIHtcbiAgICAvLyBHSVZFTlxuICAgIGNvbnN0IHN0YWNrID0gbmV3IFN0YWNrKCk7XG5cbiAgICAvLyBXSEVOXG4gICAgY29uc3QgYyA9IENlcnRpZmljYXRlLmZyb21DZXJ0aWZpY2F0ZUFybihzdGFjaywgJ0ltcG9ydGVkJywgJ2NlcnQtYXJuJyk7XG5cbiAgICAvLyBUSEVOXG4gICAgdGVzdC5kZWVwRXF1YWwoYy5jZXJ0aWZpY2F0ZUFybiwgJ2NlcnQtYXJuJyk7XG4gICAgdGVzdC5kb25lKCk7XG4gIH0sXG5cbiAgJ2NhbiBjb25maWd1cmUgdmFsaWRhdGlvbiBtZXRob2QnKHRlc3Q6IFRlc3QpIHtcbiAgICBjb25zdCBzdGFjayA9IG5ldyBTdGFjaygpO1xuXG4gICAgbmV3IENlcnRpZmljYXRlKHN0YWNrLCAnQ2VydGlmaWNhdGUnLCB7XG4gICAgICBkb21haW5OYW1lOiAndGVzdC5leGFtcGxlLmNvbScsXG4gICAgICB2YWxpZGF0aW9uTWV0aG9kOiBWYWxpZGF0aW9uTWV0aG9kLkROUyxcbiAgICB9KTtcblxuICAgIGV4cGVjdChzdGFjaykudG8oaGF2ZVJlc291cmNlKCdBV1M6OkNlcnRpZmljYXRlTWFuYWdlcjo6Q2VydGlmaWNhdGUnLCB7XG4gICAgICBEb21haW5OYW1lOiAndGVzdC5leGFtcGxlLmNvbScsXG4gICAgICBWYWxpZGF0aW9uTWV0aG9kOiAnRE5TJyxcbiAgICB9KSk7XG5cbiAgICB0ZXN0LmRvbmUoKTtcbiAgfSxcblxuICAnbmVlZHMgdmFsaWRhdGlvbiBkb21haW4gc3VwcGxpZWQgaWYgZG9tYWluIGNvbnRhaW5zIGEgdG9rZW4nKHRlc3Q6IFRlc3QpIHtcbiAgICBjb25zdCBzdGFjayA9IG5ldyBTdGFjaygpO1xuXG4gICAgdGVzdC50aHJvd3MoKCkgPT4ge1xuICAgICAgY29uc3QgZG9tYWluTmFtZSA9IExhenkuc3RyaW5nVmFsdWUoeyBwcm9kdWNlOiAoKSA9PiAnZXhhbXBsZS5jb20nIH0pO1xuICAgICAgbmV3IENlcnRpZmljYXRlKHN0YWNrLCAnQ2VydGlmaWNhdGUnLCB7XG4gICAgICAgIGRvbWFpbk5hbWUsXG4gICAgICB9KTtcbiAgICB9LCAvJ3ZhbGlkYXRpb25Eb21haW5zJyBuZWVkcyB0byBiZSBzdXBwbGllZC8pO1xuXG4gICAgdGVzdC5kb25lKCk7XG4gIH0sXG5cbiAgJ3ZhbGlkYXRpb25kb21haW5zIGNhbiBiZSBnaXZlbiBmb3IgYSBUb2tlbicodGVzdDogVGVzdCkge1xuICAgIGNvbnN0IHN0YWNrID0gbmV3IFN0YWNrKCk7XG5cbiAgICBjb25zdCBkb21haW5OYW1lID0gTGF6eS5zdHJpbmdWYWx1ZSh7IHByb2R1Y2U6ICgpID0+ICdteS5leGFtcGxlLmNvbScgfSk7XG4gICAgbmV3IENlcnRpZmljYXRlKHN0YWNrLCAnQ2VydGlmaWNhdGUnLCB7XG4gICAgICBkb21haW5OYW1lLFxuICAgICAgdmFsaWRhdGlvbkRvbWFpbnM6IHtcbiAgICAgICAgW2RvbWFpbk5hbWVdOiAnZXhhbXBsZS5jb20nLFxuICAgICAgfSxcbiAgICB9KTtcblxuICAgIGV4cGVjdChzdGFjaykudG8oaGF2ZVJlc291cmNlKCdBV1M6OkNlcnRpZmljYXRlTWFuYWdlcjo6Q2VydGlmaWNhdGUnLCB7XG4gICAgICBEb21haW5OYW1lOiAnbXkuZXhhbXBsZS5jb20nLFxuICAgICAgRG9tYWluVmFsaWRhdGlvbk9wdGlvbnM6IFt7XG4gICAgICAgIERvbWFpbk5hbWU6ICdteS5leGFtcGxlLmNvbScsXG4gICAgICAgIFZhbGlkYXRpb25Eb21haW46ICdleGFtcGxlLmNvbScsXG4gICAgICB9XSxcbiAgICB9KSk7XG5cbiAgICB0ZXN0LmRvbmUoKTtcbiAgfSxcbn07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.certificate.js","sourceRoot":"","sources":["test.certificate.ts"],"names":[],"mappings":"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","sourcesContent":["import { expect, haveResource } from '@aws-cdk/assert';\nimport * as route53 from '@aws-cdk/aws-route53';\nimport { Lazy, Stack } from '@aws-cdk/core';\nimport { Test } from 'nodeunit';\nimport { Certificate, CertificateValidation, ValidationMethod } from '../lib';\n\nexport = {\n  'apex domain selection by default'(test: Test) {\n    const stack = new Stack();\n\n    new Certificate(stack, 'Certificate', {\n      domainName: 'test.example.com',\n    });\n\n    expect(stack).to(haveResource('AWS::CertificateManager::Certificate', {\n      DomainName: 'test.example.com',\n      DomainValidationOptions: [{\n        DomainName: 'test.example.com',\n        ValidationDomain: 'example.com',\n      }],\n    }));\n\n    test.done();\n  },\n\n  'validation domain can be overridden'(test: Test) {\n    const stack = new Stack();\n\n    new Certificate(stack, 'Certificate', {\n      domainName: 'test.example.com',\n      validationDomains: {\n        'test.example.com': 'test.example.com',\n      },\n    });\n\n    expect(stack).to(haveResource('AWS::CertificateManager::Certificate', {\n      DomainValidationOptions: [{\n        DomainName: 'test.example.com',\n        ValidationDomain: 'test.example.com',\n      }],\n    }));\n\n    test.done();\n  },\n\n  'export and import'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n\n    // WHEN\n    const c = Certificate.fromCertificateArn(stack, 'Imported', 'cert-arn');\n\n    // THEN\n    test.deepEqual(c.certificateArn, 'cert-arn');\n    test.done();\n  },\n\n  'can configure validation method'(test: Test) {\n    const stack = new Stack();\n\n    new Certificate(stack, 'Certificate', {\n      domainName: 'test.example.com',\n      validationMethod: ValidationMethod.DNS,\n    });\n\n    expect(stack).to(haveResource('AWS::CertificateManager::Certificate', {\n      DomainName: 'test.example.com',\n      ValidationMethod: 'DNS',\n    }));\n\n    test.done();\n  },\n\n  'needs validation domain supplied if domain contains a token'(test: Test) {\n    const stack = new Stack();\n\n    test.throws(() => {\n      const domainName = Lazy.stringValue({ produce: () => 'example.com' });\n      new Certificate(stack, 'Certificate', {\n        domainName,\n      });\n    }, /'validationDomains' needs to be supplied/);\n\n    test.done();\n  },\n\n  'validationdomains can be given for a Token'(test: Test) {\n    const stack = new Stack();\n\n    const domainName = Lazy.stringValue({ produce: () => 'my.example.com' });\n    new Certificate(stack, 'Certificate', {\n      domainName,\n      validationDomains: {\n        [domainName]: 'example.com',\n      },\n    });\n\n    expect(stack).to(haveResource('AWS::CertificateManager::Certificate', {\n      DomainName: 'my.example.com',\n      DomainValidationOptions: [{\n        DomainName: 'my.example.com',\n        ValidationDomain: 'example.com',\n      }],\n    }));\n\n    test.done();\n  },\n\n  'CertificateValidation.fromEmail'(test: Test) {\n    const stack = new Stack();\n\n    new Certificate(stack, 'Certificate', {\n      domainName: 'test.example.com',\n      subjectAlternativeNames: ['extra.example.com'],\n      validation: CertificateValidation.fromEmail({\n        'test.example.com': 'example.com',\n      }),\n    });\n\n    expect(stack).to(haveResource('AWS::CertificateManager::Certificate', {\n      DomainName: 'test.example.com',\n      SubjectAlternativeNames: ['extra.example.com'],\n      DomainValidationOptions: [\n        {\n          DomainName: 'test.example.com',\n          ValidationDomain: 'example.com',\n        },\n        {\n          DomainName: 'extra.example.com',\n          ValidationDomain: 'example.com',\n        },\n      ],\n      ValidationMethod: 'EMAIL',\n    }));\n\n    test.done();\n  },\n\n  'CertificateValidation.fromDns'(test: Test) {\n    const stack = new Stack();\n\n    new Certificate(stack, 'Certificate', {\n      domainName: 'test.example.com',\n      subjectAlternativeNames: ['extra.example.com'],\n      validation: CertificateValidation.fromDns(),\n    });\n\n    expect(stack).to(haveResource('AWS::CertificateManager::Certificate', {\n      DomainName: 'test.example.com',\n      SubjectAlternativeNames: ['extra.example.com'],\n      ValidationMethod: 'DNS',\n    }));\n\n    test.done();\n  },\n\n  'CertificateValidation.fromDns with hosted zone'(test: Test) {\n    const stack = new Stack();\n\n    const exampleCom = new route53.HostedZone(stack, 'ExampleCom', {\n      zoneName: 'example.com',\n    });\n\n    new Certificate(stack, 'Certificate', {\n      domainName: 'test.example.com',\n      validation: CertificateValidation.fromDns(exampleCom),\n    });\n\n    expect(stack).to(haveResource('AWS::CertificateManager::Certificate', {\n      DomainName: 'test.example.com',\n      DomainValidationOptions: [\n        {\n          DomainName: 'test.example.com',\n          HostedZoneId: {\n            Ref: 'ExampleCom20E1324B',\n          },\n        },\n      ],\n      ValidationMethod: 'DNS',\n    }));\n\n    test.done();\n  },\n\n  'CertificateValidation.fromDnsMultiZone'(test: Test) {\n    const stack = new Stack();\n\n    const exampleCom = new route53.HostedZone(stack, 'ExampleCom', {\n      zoneName: 'example.com',\n    });\n\n    const exampleNet = new route53.HostedZone(stack, 'ExampleNet', {\n      zoneName: 'example.com',\n    });\n\n    new Certificate(stack, 'Certificate', {\n      domainName: 'test.example.com',\n      subjectAlternativeNames: ['cool.example.com', 'test.example.net'],\n      validation: CertificateValidation.fromDnsMultiZone({\n        'test.example.com': exampleCom,\n        'cool.example.com': exampleCom,\n        'test.example.net': exampleNet,\n      }),\n    });\n\n    expect(stack).to(haveResource('AWS::CertificateManager::Certificate', {\n      DomainName: 'test.example.com',\n      DomainValidationOptions: [\n        {\n          DomainName: 'test.example.com',\n          HostedZoneId: {\n            Ref: 'ExampleCom20E1324B',\n          },\n        },\n        {\n          DomainName: 'cool.example.com',\n          HostedZoneId: {\n            Ref: 'ExampleCom20E1324B',\n          },\n        },\n        {\n          DomainName: 'test.example.net',\n          HostedZoneId: {\n            Ref: 'ExampleNetF7CA40C9',\n          },\n        },\n      ],\n      ValidationMethod: 'DNS',\n    }));\n\n    test.done();\n  },\n};\n"]}

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

1225574

increased by3.26%

Number of package files

42

increased by5%

Lines of code

18563

increased by1.65%

Number of lines in readme file

95

increased by28.38%

Dependency changes

• + Added@aws-cdk/assets@1.52.0(transitive)

• + Added@aws-cdk/aws-cloudwatch@1.52.0(transitive)

• + Added@aws-cdk/aws-codeguruprofiler@1.52.0(transitive)

• + Added@aws-cdk/aws-ec2@1.52.0(transitive)

• + Added@aws-cdk/aws-efs@1.52.0(transitive)

• + Added@aws-cdk/aws-events@1.52.0(transitive)

• + Added@aws-cdk/aws-iam@1.52.0(transitive)

• + Added@aws-cdk/aws-kms@1.52.0(transitive)

• + Added@aws-cdk/aws-lambda@1.52.0(transitive)

• + Added@aws-cdk/aws-logs@1.52.0(transitive)

• + Added@aws-cdk/aws-route53@1.52.0(transitive)

• + Added@aws-cdk/aws-s3@1.52.0(transitive)

• + Added@aws-cdk/aws-s3-assets@1.52.0(transitive)

• + Added@aws-cdk/aws-sqs@1.52.0(transitive)

• + Added@aws-cdk/aws-ssm@1.52.0(transitive)

• + Added@aws-cdk/cloud-assembly-schema@1.52.0(transitive)

• + Added@aws-cdk/core@1.52.0(transitive)

• + Added@aws-cdk/cx-api@1.52.0(transitive)

• + Added@aws-cdk/region-info@1.52.0(transitive)

• - Removed@aws-cdk/assets@1.51.0(transitive)

• - Removed@aws-cdk/aws-cloudwatch@1.51.0(transitive)

• - Removed@aws-cdk/aws-ec2@1.51.0(transitive)

• - Removed@aws-cdk/aws-efs@1.51.0(transitive)

• - Removed@aws-cdk/aws-events@1.51.0(transitive)

• - Removed@aws-cdk/aws-iam@1.51.0(transitive)

• - Removed@aws-cdk/aws-kms@1.51.0(transitive)

• - Removed@aws-cdk/aws-lambda@1.51.0(transitive)

• - Removed@aws-cdk/aws-logs@1.51.0(transitive)

• - Removed@aws-cdk/aws-route53@1.51.0(transitive)

• - Removed@aws-cdk/aws-s3@1.51.0(transitive)

• - Removed@aws-cdk/aws-s3-assets@1.51.0(transitive)

• - Removed@aws-cdk/aws-sqs@1.51.0(transitive)

• - Removed@aws-cdk/aws-ssm@1.51.0(transitive)

• - Removed@aws-cdk/cloud-assembly-schema@1.51.0(transitive)

• - Removed@aws-cdk/core@1.51.0(transitive)

• - Removed@aws-cdk/cx-api@1.51.0(transitive)

• - Removed@aws-cdk/region-info@1.51.0(transitive)

• Updated@aws-cdk/aws-iam@1.52.0

• Updated@aws-cdk/aws-lambda@1.52.0

• Updated@aws-cdk/aws-route53@1.52.0

• Updated@aws-cdk/core@1.52.0