terraconstructs 0.0.8

package/lib/aws/cloudwatch/composite-alarm.js

@@ -0,0 +1,98 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeAlarm = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const arn_1 = require("../arn");
+const aws_stack_1 = require("../aws-stack");
+const alarm_base_1 = require("./alarm-base");
+const duration_1 = require("../../duration");
+/**
+ * A Composite Alarm based on Alarm Rule.
+ */
+class CompositeAlarm extends alarm_base_1.AlarmBase {
+    /**
+     * Import an existing CloudWatch composite alarm provided an Name.
+     *
+     * @param scope The parent creating construct (usually `this`)
+     * @param id The construct's name
+     * @param compositeAlarmName Composite Alarm Name
+     */
+    static fromCompositeAlarmName(scope, id, compositeAlarmName) {
+        const stack = aws_stack_1.AwsStack.ofAwsConstruct(scope);
+        return this.fromCompositeAlarmArn(scope, id, stack.formatArn({
+            service: "cloudwatch",
+            resource: "alarm",
+            resourceName: compositeAlarmName,
+            arnFormat: arn_1.ArnFormat.COLON_RESOURCE_NAME,
+        }));
+    }
+    /**
+     * Import an existing CloudWatch composite alarm provided an ARN.
+     *
+     * @param scope The parent creating construct (usually `this`)
+     * @param id The construct's name
+     * @param compositeAlarmArn Composite Alarm ARN (i.e. arn:aws:cloudwatch:<region>:<account-id>:alarm:CompositeAlarmName)
+     */
+    static fromCompositeAlarmArn(scope, id, compositeAlarmArn) {
+        class Import extends alarm_base_1.AlarmBase {
+            constructor() {
+                super(...arguments);
+                this.alarmArn = compositeAlarmArn;
+                this.alarmName = aws_stack_1.AwsStack.ofAwsConstruct(scope).splitArn(compositeAlarmArn, arn_1.ArnFormat.COLON_RESOURCE_NAME).resourceName;
+            }
+        }
+        return new Import(scope, id);
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        const alarmName = props.compositeAlarmName ||
+            this.stack.uniqueResourceName(this, {
+                prefix: this.gridUUID,
+                maxLength: 255,
+            });
+        if (props.alarmRule.renderAlarmRule().length > 10240) {
+            throw new Error("Alarm Rule expression cannot be greater than 10240 characters, please reduce the conditions in the Alarm Rule");
+        }
+        let extensionPeriod = props.actionsSuppressorExtensionPeriod;
+        let waitPeriod = props.actionsSuppressorWaitPeriod;
+        if (props.actionsSuppressor === undefined) {
+            if (extensionPeriod !== undefined || waitPeriod !== undefined) {
+                throw new Error("ActionsSuppressor Extension/Wait Periods require an ActionsSuppressor to be set.");
+            }
+        }
+        else {
+            extensionPeriod = extensionPeriod ?? duration_1.Duration.minutes(1);
+            waitPeriod = waitPeriod ?? duration_1.Duration.minutes(1);
+        }
+        this.alarmRule = props.alarmRule.renderAlarmRule();
+        this.resource = new provider_aws_1.cloudwatchCompositeAlarm.CloudwatchCompositeAlarm(this, "Resource", {
+            alarmName,
+            alarmRule: this.alarmRule,
+            alarmDescription: props.alarmDescription,
+            actionsEnabled: props.actionsEnabled,
+            alarmActions: cdktf_1.Lazy.listValue({ produce: () => this.alarmActionArns }),
+            insufficientDataActions: cdktf_1.Lazy.listValue({
+                produce: () => this.insufficientDataActionArns,
+            }),
+            okActions: cdktf_1.Lazy.listValue({ produce: () => this.okActionArns }),
+            ...(props.actionsSuppressor
+                ? {
+                    actionsSuppressor: {
+                        alarm: props.actionsSuppressor?.alarmArn,
+                        extensionPeriod: extensionPeriod.toSeconds(),
+                        waitPeriod: waitPeriod.toSeconds(),
+                    },
+                }
+                : undefined),
+        });
+        this.alarmName = this.resource.id;
+        this.alarmArn = this.resource.arn;
+    }
+}
+exports.CompositeAlarm = CompositeAlarm;
+_a = JSII_RTTI_SYMBOL_1;
+CompositeAlarm[_a] = { fqn: "terraconstructs.aws.cloudwatch.CompositeAlarm", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"composite-alarm.js","sourceRoot":"","sources":["../../../src/aws/cloudwatch/composite-alarm.ts"],"names":[],"mappings":"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","sourcesContent":["import { cloudwatchCompositeAlarm } from \"@cdktf/provider-aws\";\nimport { Lazy } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { ArnFormat } from \"../arn\";\nimport { AwsConstructProps } from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport { AlarmBase, IAlarm, IAlarmRule } from \"./alarm-base\";\nimport { Duration } from \"../../duration\";\n\n/**\n * Properties for creating a Composite Alarm\n */\nexport interface CompositeAlarmProps extends AwsConstructProps {\n  /**\n   * Whether the actions for this alarm are enabled\n   *\n   * @default true\n   */\n  readonly actionsEnabled?: boolean;\n\n  /**\n   * Description for the alarm\n   *\n   * @default - No description.\n   */\n  readonly alarmDescription?: string;\n\n  /**\n   * Name of the alarm\n   *\n   * @default - Automatically generated name.\n   */\n  readonly compositeAlarmName?: string;\n\n  /**\n   * Expression that specifies which other alarms are to be evaluated to determine this composite alarm's state.\n   */\n  readonly alarmRule: IAlarmRule;\n\n  /**\n   * Actions will be suppressed if the suppressor alarm is in the ALARM state.\n   *\n   * @default - alarm will not be suppressed.\n   */\n  readonly actionsSuppressor?: IAlarm;\n\n  /**\n   * The maximum duration that the composite alarm waits after suppressor alarm goes out of the ALARM state.\n   * After this time, the composite alarm performs its actions.\n   *\n   * @default - 1 minute extension period will be set.\n   */\n  readonly actionsSuppressorExtensionPeriod?: Duration;\n\n  /**\n   * The maximum duration that the composite alarm waits for the suppressor alarm to go into the ALARM state.\n   * After this time, the composite alarm performs its actions.\n   *\n   * @default - 1 minute wait period will be set.\n   */\n  readonly actionsSuppressorWaitPeriod?: Duration;\n}\n\n/**\n * A Composite Alarm based on Alarm Rule.\n */\nexport class CompositeAlarm extends AlarmBase {\n  /**\n   * Import an existing CloudWatch composite alarm provided an Name.\n   *\n   * @param scope The parent creating construct (usually `this`)\n   * @param id The construct's name\n   * @param compositeAlarmName Composite Alarm Name\n   */\n  public static fromCompositeAlarmName(\n    scope: Construct,\n    id: string,\n    compositeAlarmName: string,\n  ): IAlarm {\n    const stack = AwsStack.ofAwsConstruct(scope);\n\n    return this.fromCompositeAlarmArn(\n      scope,\n      id,\n      stack.formatArn({\n        service: \"cloudwatch\",\n        resource: \"alarm\",\n        resourceName: compositeAlarmName,\n        arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n      }),\n    );\n  }\n\n  /**\n   * Import an existing CloudWatch composite alarm provided an ARN.\n   *\n   * @param scope The parent creating construct (usually `this`)\n   * @param id The construct's name\n   * @param compositeAlarmArn Composite Alarm ARN (i.e. arn:aws:cloudwatch:<region>:<account-id>:alarm:CompositeAlarmName)\n   */\n  public static fromCompositeAlarmArn(\n    scope: Construct,\n    id: string,\n    compositeAlarmArn: string,\n  ): IAlarm {\n    class Import extends AlarmBase implements IAlarm {\n      public readonly alarmArn = compositeAlarmArn;\n      public readonly alarmName = AwsStack.ofAwsConstruct(scope).splitArn(\n        compositeAlarmArn,\n        ArnFormat.COLON_RESOURCE_NAME,\n      ).resourceName!;\n    }\n    return new Import(scope, id);\n  }\n  public readonly resource: cloudwatchCompositeAlarm.CloudwatchCompositeAlarm;\n\n  /**\n   * ARN of this alarm\n   *\n   * @attribute\n   */\n  public readonly alarmArn: string;\n\n  /**\n   * Name of this alarm.\n   *\n   * @attribute\n   */\n  public readonly alarmName: string;\n\n  private readonly alarmRule: string;\n\n  constructor(scope: Construct, id: string, props: CompositeAlarmProps) {\n    super(scope, id);\n    const alarmName =\n      props.compositeAlarmName ||\n      this.stack.uniqueResourceName(this, {\n        prefix: this.gridUUID,\n        maxLength: 255,\n      });\n\n    if (props.alarmRule.renderAlarmRule().length > 10240) {\n      throw new Error(\n        \"Alarm Rule expression cannot be greater than 10240 characters, please reduce the conditions in the Alarm Rule\",\n      );\n    }\n\n    let extensionPeriod = props.actionsSuppressorExtensionPeriod;\n    let waitPeriod = props.actionsSuppressorWaitPeriod;\n    if (props.actionsSuppressor === undefined) {\n      if (extensionPeriod !== undefined || waitPeriod !== undefined) {\n        throw new Error(\n          \"ActionsSuppressor Extension/Wait Periods require an ActionsSuppressor to be set.\",\n        );\n      }\n    } else {\n      extensionPeriod = extensionPeriod ?? Duration.minutes(1);\n      waitPeriod = waitPeriod ?? Duration.minutes(1);\n    }\n\n    this.alarmRule = props.alarmRule.renderAlarmRule();\n\n    this.resource = new cloudwatchCompositeAlarm.CloudwatchCompositeAlarm(\n      this,\n      \"Resource\",\n      {\n        alarmName,\n        alarmRule: this.alarmRule,\n        alarmDescription: props.alarmDescription,\n        actionsEnabled: props.actionsEnabled,\n        alarmActions: Lazy.listValue({ produce: () => this.alarmActionArns }),\n        insufficientDataActions: Lazy.listValue({\n          produce: () => this.insufficientDataActionArns,\n        }),\n        okActions: Lazy.listValue({ produce: () => this.okActionArns }),\n        ...(props.actionsSuppressor\n          ? {\n              actionsSuppressor: {\n                alarm: props.actionsSuppressor?.alarmArn,\n                extensionPeriod: extensionPeriod!.toSeconds(),\n                waitPeriod: waitPeriod!.toSeconds(),\n              },\n            }\n          : undefined),\n      },\n    );\n\n    this.alarmName = this.resource.id;\n    this.alarmArn = this.resource.arn;\n  }\n}\n"]}

package/lib/aws/cloudwatch/dashboard.d.ts

@@ -0,0 +1,137 @@
+import { cloudwatchDashboard } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { AwsConstructBase, AwsConstructProps } from "../aws-construct";
+import { IVariable } from "./variable";
+import { IWidget } from "./widget";
+import { Duration } from "../../duration";
+/**
+ * Specify the period for graphs when the CloudWatch dashboard loads
+ */
+export declare enum PeriodOverride {
+    /**
+     * Period of all graphs on the dashboard automatically adapt to the time range of the dashboard.
+     */
+    AUTO = "auto",
+    /**
+     * Period set for each graph will be used
+     */
+    INHERIT = "inherit"
+}
+/**
+ * Properties for defining a CloudWatch Dashboard
+ */
+export interface DashboardProps extends AwsConstructProps {
+    /**
+     * Name of the dashboard.
+     *
+     * If set, must only contain alphanumerics, dash (-) and underscore (_)
+     *
+     * @default - automatically generated name
+     */
+    readonly dashboardName?: string;
+    /**
+     * Interval duration for metrics.
+     * You can specify defaultInterval with the relative time(eg. cdk.Duration.days(7)).
+     *
+     * Both properties `defaultInterval` and `start` cannot be set at once.
+     *
+     * @default When the dashboard loads, the defaultInterval time will be the default time range.
+     */
+    readonly defaultInterval?: Duration;
+    /**
+     * The start of the time range to use for each widget on the dashboard.
+     * You can specify start without specifying end to specify a relative time range that ends with the current time.
+     * In this case, the value of start must begin with -P, and you can use M, H, D, W and M as abbreviations for
+     * minutes, hours, days, weeks and months. For example, -PT8H shows the last 8 hours and -P3M shows the last three months.
+     * You can also use start along with an end field, to specify an absolute time range.
+     * When specifying an absolute time range, use the ISO 8601 format. For example, 2018-12-17T06:00:00.000Z.
+     *
+     * Both properties `defaultInterval` and `start` cannot be set at once.
+     *
+     * @default When the dashboard loads, the start time will be the default time range.
+     */
+    readonly start?: string;
+    /**
+     * The end of the time range to use for each widget on the dashboard when the dashboard loads.
+     * If you specify a value for end, you must also specify a value for start.
+     * Specify an absolute time in the ISO 8601 format. For example, 2018-12-17T06:00:00.000Z.
+     *
+     * @default When the dashboard loads, the end date will be the current time.
+     */
+    readonly end?: string;
+    /**
+     * Use this field to specify the period for the graphs when the dashboard loads.
+     * Specifying `Auto` causes the period of all graphs on the dashboard to automatically adapt to the time range of the dashboard.
+     * Specifying `Inherit` ensures that the period set for each graph is always obeyed.
+     *
+     * @default Auto
+     */
+    readonly periodOverride?: PeriodOverride;
+    /**
+     * Initial set of widgets on the dashboard
+     *
+     * One array represents a row of widgets.
+     *
+     * @default - No widgets
+     */
+    readonly widgets?: IWidget[][];
+    /**
+     * A list of dashboard variables
+     *
+     * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_dashboard_variables.html#cloudwatch_dashboard_variables_types
+     *
+     * @default - No variables
+     */
+    readonly variables?: IVariable[];
+}
+export interface DashboardOutputs {
+    /**
+     * The name of this dashboard
+     * @attribute
+     */
+    readonly dashboardName: string;
+    /**
+     * ARN of this dashboard
+     * @attribute
+     */
+    readonly dashboardArn: string;
+}
+/**
+ * A CloudWatch dashboard
+ */
+export declare class Dashboard extends AwsConstructBase {
+    readonly resource: cloudwatchDashboard.CloudwatchDashboard;
+    /**
+     * The name of this dashboard
+     *
+     * @attribute
+     */
+    readonly dashboardName: string;
+    /**
+     * ARN of this dashboard
+     *
+     * @attribute
+     */
+    readonly dashboardArn: string;
+    get dashboardOutputs(): DashboardOutputs;
+    get outputs(): Record<string, any>;
+    private readonly rows;
+    private readonly variables;
+    constructor(scope: Construct, id: string, props?: DashboardProps);
+    /**
+     * Add a widget to the dashboard.
+     *
+     * Widgets given in multiple calls to add() will be laid out stacked on
+     * top of each other.
+     *
+     * Multiple widgets added in the same call to add() will be laid out next
+     * to each other.
+     */
+    addWidgets(...widgets: IWidget[]): void;
+    /**
+     * Add a variable to the dashboard.
+     *
+     * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_dashboard_variables.html
+     */
+    addVariable(variable: IVariable): void;
+}

package/lib/aws/cloudwatch/dashboard.js

@@ -0,0 +1,141 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dashboard = exports.PeriodOverride = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-cloudwatch/lib/dashboard.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+const layout_1 = require("./layout");
+/**
+ * Specify the period for graphs when the CloudWatch dashboard loads
+ */
+var PeriodOverride;
+(function (PeriodOverride) {
+    /**
+     * Period of all graphs on the dashboard automatically adapt to the time range of the dashboard.
+     */
+    PeriodOverride["AUTO"] = "auto";
+    /**
+     * Period set for each graph will be used
+     */
+    PeriodOverride["INHERIT"] = "inherit";
+})(PeriodOverride || (exports.PeriodOverride = PeriodOverride = {}));
+/**
+ * A CloudWatch dashboard
+ */
+class Dashboard extends aws_construct_1.AwsConstructBase {
+    get dashboardOutputs() {
+        return {
+            dashboardName: this.dashboardName,
+            dashboardArn: this.dashboardArn,
+        };
+    }
+    get outputs() {
+        return this.dashboardOutputs;
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.rows = [];
+        this.variables = [];
+        const dashboardName = props.dashboardName ||
+            this.stack.uniqueResourceName(this, {
+                prefix: this.gridUUID,
+                allowedSpecialCharacters: "-_",
+            });
+        if (dashboardName &&
+            !cdktf_1.Token.isUnresolved(dashboardName) &&
+            !dashboardName.match(/^[\w-]+$/)) {
+            throw new Error([
+                `The value ${dashboardName} for field dashboardName contains invalid characters.`,
+                "It can only contain alphanumerics, dash (-) and underscore (_).",
+            ].join(" "));
+        }
+        if (props.start !== undefined && props.defaultInterval !== undefined) {
+            throw new Error("both properties defaultInterval and start cannot be set at once");
+        }
+        if (props.end !== undefined && props.start === undefined) {
+            throw new Error("If you specify a value for end, you must also specify a value for start.");
+        }
+        this.resource = new provider_aws_1.cloudwatchDashboard.CloudwatchDashboard(this, "Resource", {
+            dashboardName,
+            dashboardBody: cdktf_1.Lazy.stringValue({
+                produce: () => {
+                    const column = new layout_1.Column(...this.rows);
+                    column.position(0, 0);
+                    return aws_stack_1.AwsStack.ofAwsConstruct(this).toJsonString({
+                        start: props.defaultInterval !== undefined
+                            ? `-${props.defaultInterval?.toIsoString()}`
+                            : props.start,
+                        end: props.defaultInterval !== undefined ? undefined : props.end,
+                        periodOverride: props.periodOverride,
+                        widgets: column.toJson(),
+                        variables: this.variables.length > 0
+                            ? this.variables.map((variable) => variable.toJson())
+                            : undefined,
+                    });
+                },
+            }),
+        });
+        this.dashboardName = this.resource.dashboardName;
+        (props.widgets || []).forEach((row) => {
+            this.addWidgets(...row);
+        });
+        (props.variables || []).forEach((variable) => this.addVariable(variable));
+        this.dashboardArn = this.resource.dashboardArn;
+    }
+    /**
+     * Add a widget to the dashboard.
+     *
+     * Widgets given in multiple calls to add() will be laid out stacked on
+     * top of each other.
+     *
+     * Multiple widgets added in the same call to add() will be laid out next
+     * to each other.
+     */
+    addWidgets(...widgets) {
+        if (widgets.length === 0) {
+            return;
+        }
+        const warnings = allWidgetsDeep(widgets).reduce((prev, curr) => {
+            return {
+                ...prev,
+                ...curr.warningsV2,
+            };
+        }, {});
+        for (const [_, message] of Object.entries(warnings ?? {})) {
+            // TODO: v2 warning with message id
+            cdktf_1.Annotations.of(this).addWarning(message);
+        }
+        const w = widgets.length > 1 ? new layout_1.Row(...widgets) : widgets[0];
+        this.rows.push(w);
+    }
+    /**
+     * Add a variable to the dashboard.
+     *
+     * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_dashboard_variables.html
+     */
+    addVariable(variable) {
+        this.variables.push(variable);
+    }
+}
+exports.Dashboard = Dashboard;
+_a = JSII_RTTI_SYMBOL_1;
+Dashboard[_a] = { fqn: "terraconstructs.aws.cloudwatch.Dashboard", version: "0.0.8" };
+function allWidgetsDeep(ws) {
+    const ret = new Array();
+    ws.forEach(recurse);
+    return ret;
+    function recurse(w) {
+        ret.push(w);
+        if (hasSubWidgets(w)) {
+            w.widgets.forEach(recurse);
+        }
+    }
+}
+function hasSubWidgets(w) {
+    return "widgets" in w;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboard.js","sourceRoot":"","sources":["../../../src/aws/cloudwatch/dashboard.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-cloudwatch/lib/dashboard.ts\n\nimport { cloudwatchDashboard } from \"@cdktf/provider-aws\";\nimport { Lazy, Token, Annotations } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { AwsConstructBase, AwsConstructProps } from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport { Column, Row } from \"./layout\";\nimport { IVariable } from \"./variable\";\nimport { IWidget } from \"./widget\";\nimport { Duration } from \"../../duration\";\n\n/**\n * Specify the period for graphs when the CloudWatch dashboard loads\n */\nexport enum PeriodOverride {\n  /**\n   * Period of all graphs on the dashboard automatically adapt to the time range of the dashboard.\n   */\n  AUTO = \"auto\",\n\n  /**\n   * Period set for each graph will be used\n   */\n  INHERIT = \"inherit\",\n}\n\n/**\n * Properties for defining a CloudWatch Dashboard\n */\nexport interface DashboardProps extends AwsConstructProps {\n  /**\n   * Name of the dashboard.\n   *\n   * If set, must only contain alphanumerics, dash (-) and underscore (_)\n   *\n   * @default - automatically generated name\n   */\n  readonly dashboardName?: string;\n\n  /**\n   * Interval duration for metrics.\n   * You can specify defaultInterval with the relative time(eg. cdk.Duration.days(7)).\n   *\n   * Both properties `defaultInterval` and `start` cannot be set at once.\n   *\n   * @default When the dashboard loads, the defaultInterval time will be the default time range.\n   */\n  readonly defaultInterval?: Duration;\n\n  /**\n   * The start of the time range to use for each widget on the dashboard.\n   * You can specify start without specifying end to specify a relative time range that ends with the current time.\n   * In this case, the value of start must begin with -P, and you can use M, H, D, W and M as abbreviations for\n   * minutes, hours, days, weeks and months. For example, -PT8H shows the last 8 hours and -P3M shows the last three months.\n   * You can also use start along with an end field, to specify an absolute time range.\n   * When specifying an absolute time range, use the ISO 8601 format. For example, 2018-12-17T06:00:00.000Z.\n   *\n   * Both properties `defaultInterval` and `start` cannot be set at once.\n   *\n   * @default When the dashboard loads, the start time will be the default time range.\n   */\n  readonly start?: string;\n\n  /**\n   * The end of the time range to use for each widget on the dashboard when the dashboard loads.\n   * If you specify a value for end, you must also specify a value for start.\n   * Specify an absolute time in the ISO 8601 format. For example, 2018-12-17T06:00:00.000Z.\n   *\n   * @default When the dashboard loads, the end date will be the current time.\n   */\n  readonly end?: string;\n\n  /**\n   * Use this field to specify the period for the graphs when the dashboard loads.\n   * Specifying `Auto` causes the period of all graphs on the dashboard to automatically adapt to the time range of the dashboard.\n   * Specifying `Inherit` ensures that the period set for each graph is always obeyed.\n   *\n   * @default Auto\n   */\n  readonly periodOverride?: PeriodOverride;\n\n  /**\n   * Initial set of widgets on the dashboard\n   *\n   * One array represents a row of widgets.\n   *\n   * @default - No widgets\n   */\n  readonly widgets?: IWidget[][];\n\n  /**\n   * A list of dashboard variables\n   *\n   * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_dashboard_variables.html#cloudwatch_dashboard_variables_types\n   *\n   * @default - No variables\n   */\n  readonly variables?: IVariable[];\n}\n\nexport interface DashboardOutputs {\n  /**\n   * The name of this dashboard\n   * @attribute\n   */\n  readonly dashboardName: string;\n\n  /**\n   * ARN of this dashboard\n   * @attribute\n   */\n  readonly dashboardArn: string;\n}\n\n/**\n * A CloudWatch dashboard\n */\nexport class Dashboard extends AwsConstructBase {\n  public readonly resource: cloudwatchDashboard.CloudwatchDashboard;\n  /**\n   * The name of this dashboard\n   *\n   * @attribute\n   */\n  public readonly dashboardName: string;\n\n  /**\n   * ARN of this dashboard\n   *\n   * @attribute\n   */\n  public readonly dashboardArn: string;\n\n  public get dashboardOutputs(): DashboardOutputs {\n    return {\n      dashboardName: this.dashboardName,\n      dashboardArn: this.dashboardArn,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.dashboardOutputs;\n  }\n\n  private readonly rows: IWidget[] = [];\n\n  private readonly variables: IVariable[] = [];\n\n  constructor(scope: Construct, id: string, props: DashboardProps = {}) {\n    super(scope, id, props);\n    const dashboardName =\n      props.dashboardName ||\n      this.stack.uniqueResourceName(this, {\n        prefix: this.gridUUID,\n        allowedSpecialCharacters: \"-_\",\n      });\n\n    if (\n      dashboardName &&\n      !Token.isUnresolved(dashboardName) &&\n      !dashboardName.match(/^[\\w-]+$/)\n    ) {\n      throw new Error(\n        [\n          `The value ${dashboardName} for field dashboardName contains invalid characters.`,\n          \"It can only contain alphanumerics, dash (-) and underscore (_).\",\n        ].join(\" \"),\n      );\n    }\n\n    if (props.start !== undefined && props.defaultInterval !== undefined) {\n      throw new Error(\n        \"both properties defaultInterval and start cannot be set at once\",\n      );\n    }\n\n    if (props.end !== undefined && props.start === undefined) {\n      throw new Error(\n        \"If you specify a value for end, you must also specify a value for start.\",\n      );\n    }\n\n    this.resource = new cloudwatchDashboard.CloudwatchDashboard(\n      this,\n      \"Resource\",\n      {\n        dashboardName,\n        dashboardBody: Lazy.stringValue({\n          produce: () => {\n            const column = new Column(...this.rows);\n            column.position(0, 0);\n            return AwsStack.ofAwsConstruct(this).toJsonString({\n              start:\n                props.defaultInterval !== undefined\n                  ? `-${props.defaultInterval?.toIsoString()}`\n                  : props.start,\n              end: props.defaultInterval !== undefined ? undefined : props.end,\n              periodOverride: props.periodOverride,\n              widgets: column.toJson(),\n              variables:\n                this.variables.length > 0\n                  ? this.variables.map((variable) => variable.toJson())\n                  : undefined,\n            });\n          },\n        }),\n      },\n    );\n\n    this.dashboardName = this.resource.dashboardName;\n\n    (props.widgets || []).forEach((row) => {\n      this.addWidgets(...row);\n    });\n\n    (props.variables || []).forEach((variable) => this.addVariable(variable));\n\n    this.dashboardArn = this.resource.dashboardArn;\n  }\n\n  /**\n   * Add a widget to the dashboard.\n   *\n   * Widgets given in multiple calls to add() will be laid out stacked on\n   * top of each other.\n   *\n   * Multiple widgets added in the same call to add() will be laid out next\n   * to each other.\n   */\n  public addWidgets(...widgets: IWidget[]) {\n    if (widgets.length === 0) {\n      return;\n    }\n\n    const warnings = allWidgetsDeep(widgets).reduce(\n      (prev, curr) => {\n        return {\n          ...prev,\n          ...curr.warningsV2,\n        };\n      },\n      {} as { [id: string]: string },\n    );\n    for (const [_, message] of Object.entries(warnings ?? {})) {\n      // TODO: v2 warning with message id\n      Annotations.of(this).addWarning(message);\n    }\n\n    const w = widgets.length > 1 ? new Row(...widgets) : widgets[0];\n    this.rows.push(w);\n  }\n\n  /**\n   * Add a variable to the dashboard.\n   *\n   * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_dashboard_variables.html\n   */\n  public addVariable(variable: IVariable) {\n    this.variables.push(variable);\n  }\n}\n\nfunction allWidgetsDeep(ws: IWidget[]) {\n  const ret = new Array<IWidget>();\n  ws.forEach(recurse);\n  return ret;\n\n  function recurse(w: IWidget) {\n    ret.push(w);\n    if (hasSubWidgets(w)) {\n      w.widgets.forEach(recurse);\n    }\n  }\n}\n\nfunction hasSubWidgets(w: IWidget): w is IWidget & { widgets: IWidget[] } {\n  return \"widgets\" in w;\n}\n"]}

package/lib/aws/cloudwatch/data-protection-policy.d.ts

@@ -0,0 +1,184 @@
+import { cloudwatchLogDataProtectionPolicy } from "@cdktf/provider-aws";
+import { ILogGroup } from "./log-group";
+import { IBucket } from "../storage";
+/**
+ * Creates a data protection policy for CloudWatch Logs log groups.
+ */
+export declare class DataProtectionPolicy {
+    private readonly dataProtectionPolicyProps;
+    constructor(props: DataProtectionPolicyProps);
+    /**
+     * @internal
+     */
+    _bind(_scope: ILogGroup): cloudwatchLogDataProtectionPolicy.CloudwatchLogDataProtectionPolicy;
+}
+/**
+ * Properties for creating a data protection policy
+ */
+export interface DataProtectionPolicyProps {
+    /**
+     * Name of the data protection policy
+     *
+     * @default - 'data-protection-policy-cdk'
+     */
+    readonly name?: string;
+    /**
+     * Description of the data protection policy
+     *
+     * @default - 'cdk generated data protection policy'
+     */
+    readonly description?: string;
+    /**
+     * List of data protection identifiers.
+     *
+     * Managed data identifiers must be in the following list: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL-managed-data-identifiers.html
+     * Custom data identifiers must have a valid regex defined: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL-custom-data-identifiers.html#custom-data-identifiers-constraints
+     */
+    readonly identifiers: DataIdentifier[];
+    /**
+     * CloudWatch Logs log group to send audit findings to. The log group must already exist prior to creating the data protection policy.
+     *
+     * @default - no CloudWatch Logs audit destination
+     */
+    readonly logGroupAuditDestination?: ILogGroup;
+    /**
+     * S3 bucket to send audit findings to. The bucket must already exist.
+     *
+     * @default - no S3 bucket audit destination
+     */
+    readonly s3BucketAuditDestination?: IBucket;
+    /**
+     * Amazon Kinesis Data Firehose delivery stream to send audit findings to. The delivery stream must already exist.
+     *
+     * @default - no firehose delivery stream audit destination
+     */
+    readonly deliveryStreamNameAuditDestination?: string;
+}
+/**
+ * A data protection identifier. If an identifier is supported but not in this class, it can be passed in the constructor instead.
+ */
+export declare class DataIdentifier {
+    readonly name: string;
+    static readonly ADDRESS: DataIdentifier;
+    static readonly AWSSECRETKEY: DataIdentifier;
+    static readonly BANKACCOUNTNUMBER_DE: DataIdentifier;
+    static readonly BANKACCOUNTNUMBER_ES: DataIdentifier;
+    static readonly BANKACCOUNTNUMBER_FR: DataIdentifier;
+    static readonly BANKACCOUNTNUMBER_GB: DataIdentifier;
+    static readonly BANKACCOUNTNUMBER_IT: DataIdentifier;
+    static readonly BANKACCOUNTNUMBER_US: DataIdentifier;
+    static readonly CEPCODE_BR: DataIdentifier;
+    static readonly CNPJ_BR: DataIdentifier;
+    static readonly CPFCODE_BR: DataIdentifier;
+    static readonly CREDITCARDEXPIRATION: DataIdentifier;
+    static readonly CREDITCARDNUMBER: DataIdentifier;
+    static readonly CREDITCARDSECURITYCODE: DataIdentifier;
+    static readonly DRIVERSLICENSE_AT: DataIdentifier;
+    static readonly DRIVERSLICENSE_AU: DataIdentifier;
+    static readonly DRIVERSLICENSE_BE: DataIdentifier;
+    static readonly DRIVERSLICENSE_BG: DataIdentifier;
+    static readonly DRIVERSLICENSE_CA: DataIdentifier;
+    static readonly DRIVERSLICENSE_CY: DataIdentifier;
+    static readonly DRIVERSLICENSE_CZ: DataIdentifier;
+    static readonly DRIVERSLICENSE_DE: DataIdentifier;
+    static readonly DRIVERSLICENSE_DK: DataIdentifier;
+    static readonly DRIVERSLICENSE_EE: DataIdentifier;
+    static readonly DRIVERSLICENSE_ES: DataIdentifier;
+    static readonly DRIVERSLICENSE_FI: DataIdentifier;
+    static readonly DRIVERSLICENSE_FR: DataIdentifier;
+    static readonly DRIVERSLICENSE_GB: DataIdentifier;
+    static readonly DRIVERSLICENSE_GR: DataIdentifier;
+    static readonly DRIVERSLICENSE_HR: DataIdentifier;
+    static readonly DRIVERSLICENSE_HU: DataIdentifier;
+    static readonly DRIVERSLICENSE_IE: DataIdentifier;
+    static readonly DRIVERSLICENSE_IT: DataIdentifier;
+    static readonly DRIVERSLICENSE_LT: DataIdentifier;
+    static readonly DRIVERSLICENSE_LU: DataIdentifier;
+    static readonly DRIVERSLICENSE_LV: DataIdentifier;
+    static readonly DRIVERSLICENSE_MT: DataIdentifier;
+    static readonly DRIVERSLICENSE_NL: DataIdentifier;
+    static readonly DRIVERSLICENSE_PL: DataIdentifier;
+    static readonly DRIVERSLICENSE_PT: DataIdentifier;
+    static readonly DRIVERSLICENSE_RO: DataIdentifier;
+    static readonly DRIVERSLICENSE_SE: DataIdentifier;
+    static readonly DRIVERSLICENSE_SI: DataIdentifier;
+    static readonly DRIVERSLICENSE_SK: DataIdentifier;
+    static readonly DRIVERSLICENSE_US: DataIdentifier;
+    static readonly DRUGENFORCEMENTAGENCYNUMBER_US: DataIdentifier;
+    static readonly ELECTORALROLLNUMBER_GB: DataIdentifier;
+    static readonly EMAILADDRESS: DataIdentifier;
+    static readonly HEALTHINSURANCECARDNUMBER_EU: DataIdentifier;
+    static readonly HEALTHINSURANCECLAIMNUMBER_US: DataIdentifier;
+    static readonly HEALTHINSURANCENUMBER_FR: DataIdentifier;
+    static readonly HEALTHCAREPROCEDURECODE_US: DataIdentifier;
+    static readonly INDIVIDUALTAXIDENTIFICATIONNUMBER_US: DataIdentifier;
+    static readonly INSEECODE_FR: DataIdentifier;
+    static readonly IPADDRESS: DataIdentifier;
+    static readonly LATLONG: DataIdentifier;
+    static readonly MEDICAREBENEFICIARYNUMBER_US: DataIdentifier;
+    static readonly NAME: DataIdentifier;
+    static readonly NATIONALDRUGCODE_US: DataIdentifier;
+    static readonly NATIONALIDENTIFICATIONNUMBER_DE: DataIdentifier;
+    static readonly NATIONALIDENTIFICATIONNUMBER_ES: DataIdentifier;
+    static readonly NATIONALIDENTIFICATIONNUMBER_IT: DataIdentifier;
+    static readonly NATIONALINSURANCENUMBER_GB: DataIdentifier;
+    static readonly NATIONALPROVIDERID_US: DataIdentifier;
+    static readonly NHSNUMBER_GB: DataIdentifier;
+    static readonly NIENUMBER_ES: DataIdentifier;
+    static readonly NIFNUMBER_ES: DataIdentifier;
+    static readonly OPENSSHPRIVATEKEY: DataIdentifier;
+    static readonly PASSPORTNUMBER_CA: DataIdentifier;
+    static readonly PASSPORTNUMBER_DE: DataIdentifier;
+    static readonly PASSPORTNUMBER_ES: DataIdentifier;
+    static readonly PASSPORTNUMBER_FR: DataIdentifier;
+    static readonly PASSPORTNUMBER_GB: DataIdentifier;
+    static readonly PASSPORTNUMBER_IT: DataIdentifier;
+    static readonly PASSPORTNUMBER_US: DataIdentifier;
+    static readonly PERMANENTRESIDENCENUMBER_CA: DataIdentifier;
+    static readonly PERSONALHEALTHNUMBER_CA: DataIdentifier;
+    static readonly PGPPRIVATEKEY: DataIdentifier;
+    static readonly PHONENUMBER_BR: DataIdentifier;
+    static readonly PHONENUMBER_DE: DataIdentifier;
+    static readonly PHONENUMBER_ES: DataIdentifier;
+    static readonly PHONENUMBER_FR: DataIdentifier;
+    static readonly PHONENUMBER_GB: DataIdentifier;
+    static readonly PHONENUMBER_IT: DataIdentifier;
+    static readonly PHONENUMBER_US: DataIdentifier;
+    static readonly PKCSPRIVATEKEY: DataIdentifier;
+    static readonly POSTALCODE_CA: DataIdentifier;
+    static readonly PUTTYPRIVATEKEY: DataIdentifier;
+    static readonly RGNUMBER_BR: DataIdentifier;
+    static readonly SOCIALINSURANCENUMBER_CA: DataIdentifier;
+    static readonly SSN_ES: DataIdentifier;
+    static readonly SSN_US: DataIdentifier;
+    static readonly TAXID_DE: DataIdentifier;
+    static readonly TAXID_ES: DataIdentifier;
+    static readonly TAXID_FR: DataIdentifier;
+    static readonly TAXID_GB: DataIdentifier;
+    static readonly VEHICLEIDENTIFICATIONNUMBER: DataIdentifier;
+    static readonly ZIPCODE_US: DataIdentifier;
+    /**
+     * Create a managed data identifier not in the list of static members. This is used to maintain forward compatibility, in case a new managed identifier is supported but not updated in CDK yet.
+     * @param name - name of the identifier.
+     */
+    constructor(name: string);
+    toString(): string;
+}
+/**
+ * A custom data identifier. Include a custom data identifier name and regular expression in the JSON policy used to define the data protection policy.
+ */
+export declare class CustomDataIdentifier extends DataIdentifier {
+    readonly name: string;
+    readonly regex: string;
+    /**
+     * Create a custom data identifier.
+     * @param name - the name of the custom data identifier. This cannot share the same name as a managed data identifier.
+     * @param regex - the regular expression to detect and mask log events for.
+     */
+    constructor(name: string, regex: string);
+    /**
+     * String representation of a CustomDataIdentifier
+     * @returns the name and RegEx of the custom data identifier
+     */
+    toString(): string;
+}