aws-cdk-lib 2.127.0__py3-none-any.whl → 2.129.0__py3-none-any.whl

aws_cdk/aws_cloudwatch/__init__.py

@@ -504,6 +504,98 @@ dashboard.add_widgets(cloudwatch.GraphWidget(
 ))
 ```
 
+### Table Widget
+
+A `TableWidget` can display any number of metrics in tabular form.
+
+```python
+# dashboard: cloudwatch.Dashboard
+# execution_count_metric: cloudwatch.Metric
+
+
+dashboard.add_widgets(cloudwatch.TableWidget(
+    title="Executions",
+    metrics=[execution_count_metric]
+))
+```
+
+The `layout` property can be used to invert the rows and columns of the table.
+The default `cloudwatch.TableLayout.HORIZONTAL` means that metrics are shown in rows and datapoints in columns.
+`cloudwatch.TableLayout.VERTICAL` means that metrics are shown in columns and datapoints in rows.
+
+```python
+# dashboard: cloudwatch.Dashboard
+
+
+dashboard.add_widgets(cloudwatch.TableWidget(
+    # ...
+
+    layout=cloudwatch.TableLayout.VERTICAL
+))
+```
+
+The `summary` property allows customizing the table to show summary columns (`columns` sub property),
+whether to make the summary columns sticky remaining in view while scrolling (`sticky` sub property),
+and to optionally only present summary columns (`hideNonSummaryColumns` sub property).
+
+```python
+# dashboard: cloudwatch.Dashboard
+
+
+dashboard.add_widgets(cloudwatch.TableWidget(
+    # ...
+
+    summary=cloudwatch.TableSummaryProps(
+        columns=[cloudwatch.TableSummaryColumn.AVERAGE],
+        hide_non_summary_columns=True,
+        sticky=True
+    )
+))
+```
+
+The `thresholds` property can be used to highlight cells with a color when the datapoint value falls within the threshold.
+
+```python
+# dashboard: cloudwatch.Dashboard
+
+
+dashboard.add_widgets(cloudwatch.TableWidget(
+    # ...
+
+    thresholds=[
+        cloudwatch.TableThreshold.above(1000, cloudwatch.Color.RED),
+        cloudwatch.TableThreshold.between(500, 1000, cloudwatch.Color.ORANGE),
+        cloudwatch.TableThreshold.below(500, cloudwatch.Color.GREEN)
+    ]
+))
+```
+
+The `showUnitsInLabel` property can be used to display what unit is associated with a metric in the label column.
+
+```python
+# dashboard: cloudwatch.Dashboard
+
+
+dashboard.add_widgets(cloudwatch.TableWidget(
+    # ...
+
+    show_units_in_label=True
+))
+```
+
+The `fullPrecision` property can be used to show as many digits as can fit in a cell, before rounding.
+
+```python
+# dashboard: cloudwatch.Dashboard
+
+
+dashboard.add_widgets(cloudwatch.TableWidget(
+    # ...
+
+    full_precision=True
+))
+```
+
 ### Gauge widget
 
 Gauge graph requires the max and min value of the left Y axis, if no value is informed the limits will be from 0 to 100.
@@ -2708,6 +2800,8 @@ class CfnAnomalyDetector(
 
     The band represents the expected "normal" range for the metric values. Anomaly detection bands can be used for visualization of a metric's expected values, and for alarms.
 
+    For more information see `Using CloudWatch anomaly detection. <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Anomaly_Detection.html>`_ .
+
     :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudwatch-anomalydetector.html
     :cloudformationResource: AWS::CloudWatch::AnomalyDetector
     :exampleMetadata: fixture=_generated
@@ -3746,6 +3840,8 @@ class CfnAnomalyDetector(
         ) -> None:
             '''Designates the CloudWatch metric and statistic that provides the time series the anomaly detector uses as input.
 
+            If you have enabled unified cross-account observability, and this account is a monitoring account, the metric can be in the same account or a source account.
+
             :param dimensions: The metric dimensions to create the anomaly detection model for.
             :param metric_name: The name of the metric to create the anomaly detection model for.
             :param namespace: The namespace of the metric to create the anomaly detection model for.
@@ -5898,20 +5994,15 @@ class Color(metaclass=jsii.JSIIMeta, jsii_type="aws-cdk-lib.aws_cloudwatch.Color
     Example::
 
         # dashboard: cloudwatch.Dashboard
-        # execution_count_metric: cloudwatch.Metric
-        # error_count_metric: cloudwatch.Metric
         
         
         dashboard.add_widgets(cloudwatch.GraphWidget(
-            title="Executions vs error rate",
-        
-            left=[execution_count_metric],
+            # ...
         
-            right=[error_count_metric.with(
-                statistic=cloudwatch.Stats.AVERAGE,
-                label="Error rate",
-                color=cloudwatch.Color.GREEN
-            )]
+            left_annotations=[cloudwatch.HorizontalAnnotation(value=1800, label=Duration.minutes(30).to_human_string(), color=cloudwatch.Color.RED), cloudwatch.HorizontalAnnotation(value=3600, label="1 hour", color="#2ca02c")
+            ],
+            vertical_annotations=[cloudwatch.VerticalAnnotation(date="2022-10-19T00:00:00Z", label="Deployment", color=cloudwatch.Color.RED)
+            ]
         ))
     '''
 
@@ -10761,9 +10852,9 @@ class _StatsProxy(Stats):
 typing.cast(typing.Any, Stats).__jsii_proxy_class__ = lambda : _StatsProxy
 
 
-@jsii.enum(jsii_type="aws-cdk-lib.aws_cloudwatch.TextWidgetBackground")
-class TextWidgetBackground(enum.Enum):
-    '''Background types available.
+@jsii.enum(jsii_type="aws-cdk-lib.aws_cloudwatch.TableLayout")
+class TableLayout(enum.Enum):
+    '''Layout for TableWidget.
 
     :exampleMetadata: infused
 
@@ -10772,43 +10863,73 @@ class TextWidgetBackground(enum.Enum):
         # dashboard: cloudwatch.Dashboard
         
         
-        dashboard.add_widgets(cloudwatch.TextWidget(
-            markdown="# Key Performance Indicators",
-            background=cloudwatch.TextWidgetBackground.TRANSPARENT
+        dashboard.add_widgets(cloudwatch.TableWidget(
+            # ...
+        
+            layout=cloudwatch.TableLayout.VERTICAL
         ))
     '''
 
-    SOLID = "SOLID"
-    '''Solid background.'''
-    TRANSPARENT = "TRANSPARENT"
-    '''Transparent background.'''
+    HORIZONTAL = "HORIZONTAL"
+    '''Data points are laid out in columns.'''
+    VERTICAL = "VERTICAL"
+    '''Data points are laid out in rows.'''
+
+
+@jsii.enum(jsii_type="aws-cdk-lib.aws_cloudwatch.TableSummaryColumn")
+class TableSummaryColumn(enum.Enum):
+    '''Standard table summary columns.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        # dashboard: cloudwatch.Dashboard
+        
+        
+        dashboard.add_widgets(cloudwatch.TableWidget(
+            # ...
+        
+            summary=cloudwatch.TableSummaryProps(
+                columns=[cloudwatch.TableSummaryColumn.AVERAGE],
+                hide_non_summary_columns=True,
+                sticky=True
+            )
+        ))
+    '''
+
+    MINIMUM = "MINIMUM"
+    '''Minimum of all data points.'''
+    MAXIMUM = "MAXIMUM"
+    '''Maximum of all data points.'''
+    SUM = "SUM"
+    '''Sum of all data points.'''
+    AVERAGE = "AVERAGE"
+    '''Average of all data points.'''
 
 
 @jsii.data_type(
-    jsii_type="aws-cdk-lib.aws_cloudwatch.TextWidgetProps",
+    jsii_type="aws-cdk-lib.aws_cloudwatch.TableSummaryProps",
     jsii_struct_bases=[],
     name_mapping={
-        "markdown": "markdown",
-        "background": "background",
-        "height": "height",
-        "width": "width",
+        "columns": "columns",
+        "hide_non_summary_columns": "hideNonSummaryColumns",
+        "sticky": "sticky",
     },
 )
-class TextWidgetProps:
+class TableSummaryProps:
     def __init__(
         self,
         *,
-        markdown: builtins.str,
-        background: typing.Optional[TextWidgetBackground] = None,
-        height: typing.Optional[jsii.Number] = None,
-        width: typing.Optional[jsii.Number] = None,
+        columns: typing.Optional[typing.Sequence[TableSummaryColumn]] = None,
+        hide_non_summary_columns: typing.Optional[builtins.bool] = None,
+        sticky: typing.Optional[builtins.bool] = None,
     ) -> None:
-        '''Properties for a Text widget.
+        '''Properties for TableWidget's summary columns.
 
-        :param markdown: The text to display, in MarkDown format.
-        :param background: Background for the widget. Default: solid
-        :param height: Height of the widget. Default: 2
-        :param width: Width of the widget, in a grid of 24 units wide. Default: 6
+        :param columns: Summary columns. Default: - No summary columns will be shown
+        :param hide_non_summary_columns: Prevent the columns of datapoints from being displayed, so that only the label and summary columns are displayed. Default: - false
+        :param sticky: Make the summary columns sticky, so that they remain in view while scrolling. Default: - false
 
         :exampleMetadata: infused
 
@@ -10817,59 +10938,55 @@ class TextWidgetProps:
             # dashboard: cloudwatch.Dashboard
             
             
-            dashboard.add_widgets(cloudwatch.TextWidget(
-                markdown="# Key Performance Indicators"
+            dashboard.add_widgets(cloudwatch.TableWidget(
+                # ...
+            
+                summary=cloudwatch.TableSummaryProps(
+                    columns=[cloudwatch.TableSummaryColumn.AVERAGE],
+                    hide_non_summary_columns=True,
+                    sticky=True
+                )
             ))
         '''
         if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__c678c9d6bdc1a1e852f5260a40406f2e09cfc10b899093e99e66b9998d086d5e)
-            check_type(argname="argument markdown", value=markdown, expected_type=type_hints["markdown"])
-            check_type(argname="argument background", value=background, expected_type=type_hints["background"])
-            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
-            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
-        self._values: typing.Dict[builtins.str, typing.Any] = {
-            "markdown": markdown,
-        }
-        if background is not None:
-            self._values["background"] = background
-        if height is not None:
-            self._values["height"] = height
-        if width is not None:
-            self._values["width"] = width
-
-    @builtins.property
-    def markdown(self) -> builtins.str:
-        '''The text to display, in MarkDown format.'''
-        result = self._values.get("markdown")
-        assert result is not None, "Required property 'markdown' is missing"
-        return typing.cast(builtins.str, result)
+            type_hints = typing.get_type_hints(_typecheckingstub__98c18eab758ffae376ffa1675e2524ad60cd0a50fd033fe135c6d98d0f5d2692)
+            check_type(argname="argument columns", value=columns, expected_type=type_hints["columns"])
+            check_type(argname="argument hide_non_summary_columns", value=hide_non_summary_columns, expected_type=type_hints["hide_non_summary_columns"])
+            check_type(argname="argument sticky", value=sticky, expected_type=type_hints["sticky"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if columns is not None:
+            self._values["columns"] = columns
+        if hide_non_summary_columns is not None:
+            self._values["hide_non_summary_columns"] = hide_non_summary_columns
+        if sticky is not None:
+            self._values["sticky"] = sticky
 
     @builtins.property
-    def background(self) -> typing.Optional[TextWidgetBackground]:
-        '''Background for the widget.
+    def columns(self) -> typing.Optional[typing.List[TableSummaryColumn]]:
+        '''Summary columns.
 
-        :default: solid
+        :default: - No summary columns will be shown
         '''
-        result = self._values.get("background")
-        return typing.cast(typing.Optional[TextWidgetBackground], result)
+        result = self._values.get("columns")
+        return typing.cast(typing.Optional[typing.List[TableSummaryColumn]], result)
 
     @builtins.property
-    def height(self) -> typing.Optional[jsii.Number]:
-        '''Height of the widget.
+    def hide_non_summary_columns(self) -> typing.Optional[builtins.bool]:
+        '''Prevent the columns of datapoints from being displayed, so that only the label and summary columns are displayed.
 
-        :default: 2
+        :default: - false
         '''
-        result = self._values.get("height")
-        return typing.cast(typing.Optional[jsii.Number], result)
+        result = self._values.get("hide_non_summary_columns")
+        return typing.cast(typing.Optional[builtins.bool], result)
 
     @builtins.property
-    def width(self) -> typing.Optional[jsii.Number]:
-        '''Width of the widget, in a grid of 24 units wide.
+    def sticky(self) -> typing.Optional[builtins.bool]:
+        '''Make the summary columns sticky, so that they remain in view while scrolling.
 
-        :default: 6
+        :default: - false
         '''
-        result = self._values.get("width")
-        return typing.cast(typing.Optional[jsii.Number], result)
+        result = self._values.get("sticky")
+        return typing.cast(typing.Optional[builtins.bool], result)
 
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
@@ -10878,85 +10995,598 @@ class TextWidgetProps:
         return not (rhs == self)
 
     def __repr__(self) -> str:
-        return "TextWidgetProps(%s)" % ", ".join(
+        return "TableSummaryProps(%s)" % ", ".join(
             k + "=" + repr(v) for k, v in self._values.items()
         )
 
 
-@jsii.enum(jsii_type="aws-cdk-lib.aws_cloudwatch.TreatMissingData")
-class TreatMissingData(enum.Enum):
-    '''Specify how missing data points are treated during alarm evaluation.
+class TableThreshold(
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_cloudwatch.TableThreshold",
+):
+    '''Thresholds for highlighting cells in TableWidget.
 
     :exampleMetadata: infused
 
     Example::
 
-        import aws_cdk as cdk
-        import aws_cdk.aws_cloudwatch as cloudwatch
+        # dashboard: cloudwatch.Dashboard
         
         
-        fn = lambda_.Function(self, "MyFunction",
-            runtime=lambda_.Runtime.NODEJS_18_X,
-            handler="index.handler",
-            code=lambda_.Code.from_asset(path.join(__dirname, "lambda-handler")),
-            timeout=Duration.minutes(5)
-        )
+        dashboard.add_widgets(cloudwatch.TableWidget(
+            # ...
         
-        if fn.timeout:
-            cloudwatch.Alarm(self, "MyAlarm",
-                metric=fn.metric_duration().with(
-                    statistic="Maximum"
-                ),
-                evaluation_periods=1,
-                datapoints_to_alarm=1,
-                threshold=fn.timeout.to_milliseconds(),
-                treat_missing_data=cloudwatch.TreatMissingData.IGNORE,
-                alarm_name="My Lambda Timeout"
-            )
+            thresholds=[
+                cloudwatch.TableThreshold.above(1000, cloudwatch.Color.RED),
+                cloudwatch.TableThreshold.between(500, 1000, cloudwatch.Color.ORANGE),
+                cloudwatch.TableThreshold.below(500, cloudwatch.Color.GREEN)
+            ]
+        ))
     '''
 
-    BREACHING = "BREACHING"
-    '''Missing data points are treated as breaching the threshold.'''
-    NOT_BREACHING = "NOT_BREACHING"
-    '''Missing data points are treated as being within the threshold.'''
-    IGNORE = "IGNORE"
-    '''The current alarm state is maintained.'''
-    MISSING = "MISSING"
-    '''The alarm does not consider missing data points when evaluating whether to change state.'''
+    @jsii.member(jsii_name="above")
+    @builtins.classmethod
+    def above(
+        cls,
+        value: jsii.Number,
+        color: typing.Optional[builtins.str] = None,
+    ) -> "TableThreshold":
+        '''A threshold for highlighting and coloring cells above the specified value.
 
+        :param value: lower bound of threshold range.
+        :param color: cell color for values within threshold range.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__70d2d8bf527174c0069d64738e83c5ebe4fd927ac2332ac0de67140546fb8616)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+            check_type(argname="argument color", value=color, expected_type=type_hints["color"])
+        return typing.cast("TableThreshold", jsii.sinvoke(cls, "above", [value, color]))
 
-@jsii.enum(jsii_type="aws-cdk-lib.aws_cloudwatch.Unit")
-class Unit(enum.Enum):
-    '''Unit for metric.
+    @jsii.member(jsii_name="below")
+    @builtins.classmethod
+    def below(
+        cls,
+        value: jsii.Number,
+        color: typing.Optional[builtins.str] = None,
+    ) -> "TableThreshold":
+        '''A threshold for highlighting and coloring cells below the specified value.
 
-    :exampleMetadata: infused
+        :param value: upper bound of threshold range.
+        :param color: cell color for values within threshold range.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__e6f92993218488cf545481e8167442910bb8b8c7c45aa7dfb6667808cb1077e6)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+            check_type(argname="argument color", value=color, expected_type=type_hints["color"])
+        return typing.cast("TableThreshold", jsii.sinvoke(cls, "below", [value, color]))
 
-    Example::
+    @jsii.member(jsii_name="between")
+    @builtins.classmethod
+    def between(
+        cls,
+        lower_bound: jsii.Number,
+        upper_bound: jsii.Number,
+        color: typing.Optional[builtins.str] = None,
+    ) -> "TableThreshold":
+        '''A threshold for highlighting and coloring cells within the specified values.
 
-        # log_group: logs.LogGroup
-        
-        mf = logs.MetricFilter(self, "MetricFilter",
-            log_group=log_group,
-            metric_namespace="MyApp",
-            metric_name="Latency",
-            filter_pattern=logs.FilterPattern.exists("$.latency"),
-            metric_value="$.latency",
-            dimensions={
-                "ErrorCode": "$.errorCode"
-            },
-            unit=cloudwatch.Unit.MILLISECONDS
-        )
-        
-        # expose a metric from the metric filter
-        metric = mf.metric()
-        
-        # you can use the metric to create a new alarm
-        cloudwatch.Alarm(self, "alarm from metric filter",
-            metric=metric,
-            threshold=100,
-            evaluation_periods=2
-        )
-    '''
+        :param lower_bound: lower bound of threshold range.
+        :param upper_bound: upper bound of threshold range.
+        :param color: cell color for values within threshold range.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__837fdebf81b3f53de6d99624ebde152b4aba1d764a0cc2bd930440701533924a)
+            check_type(argname="argument lower_bound", value=lower_bound, expected_type=type_hints["lower_bound"])
+            check_type(argname="argument upper_bound", value=upper_bound, expected_type=type_hints["upper_bound"])
+            check_type(argname="argument color", value=color, expected_type=type_hints["color"])
+        return typing.cast("TableThreshold", jsii.sinvoke(cls, "between", [lower_bound, upper_bound, color]))
+
+    @jsii.member(jsii_name="toJson")
+    def to_json(self) -> typing.Any:
+        return typing.cast(typing.Any, jsii.invoke(self, "toJson", []))
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_cloudwatch.TableWidgetProps",
+    jsii_struct_bases=[MetricWidgetProps],
+    name_mapping={
+        "height": "height",
+        "region": "region",
+        "title": "title",
+        "width": "width",
+        "end": "end",
+        "full_precision": "fullPrecision",
+        "layout": "layout",
+        "live_data": "liveData",
+        "metrics": "metrics",
+        "period": "period",
+        "set_period_to_time_range": "setPeriodToTimeRange",
+        "show_units_in_label": "showUnitsInLabel",
+        "start": "start",
+        "statistic": "statistic",
+        "summary": "summary",
+        "thresholds": "thresholds",
+    },
+)
+class TableWidgetProps(MetricWidgetProps):
+    def __init__(
+        self,
+        *,
+        height: typing.Optional[jsii.Number] = None,
+        region: typing.Optional[builtins.str] = None,
+        title: typing.Optional[builtins.str] = None,
+        width: typing.Optional[jsii.Number] = None,
+        end: typing.Optional[builtins.str] = None,
+        full_precision: typing.Optional[builtins.bool] = None,
+        layout: typing.Optional[TableLayout] = None,
+        live_data: typing.Optional[builtins.bool] = None,
+        metrics: typing.Optional[typing.Sequence[IMetric]] = None,
+        period: typing.Optional[_Duration_4839e8c3] = None,
+        set_period_to_time_range: typing.Optional[builtins.bool] = None,
+        show_units_in_label: typing.Optional[builtins.bool] = None,
+        start: typing.Optional[builtins.str] = None,
+        statistic: typing.Optional[builtins.str] = None,
+        summary: typing.Optional[typing.Union[TableSummaryProps, typing.Dict[builtins.str, typing.Any]]] = None,
+        thresholds: typing.Optional[typing.Sequence[TableThreshold]] = None,
+    ) -> None:
+        '''Properties for a TableWidget.
+
+        :param height: Height of the widget. Default: - 6 for Alarm and Graph widgets. 3 for single value widgets where most recent value of a metric is displayed.
+        :param region: The region the metrics of this graph should be taken from. Default: - Current region
+        :param title: Title for the graph. Default: - None
+        :param width: Width of the widget, in a grid of 24 units wide. Default: 6
+        :param end: The end of the time range to use for each widget independently from those of the dashboard. 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.
+        :param full_precision: Whether to show as many digits as can fit, before rounding. Default: false
+        :param layout: Table layout. Default: - TableLayout.HORIZONTAL
+        :param live_data: Whether the graph should show live data. Default: false
+        :param metrics: Metrics to display in the table. Default: - No metrics
+        :param period: The default period for all metrics in this widget. The period is the length of time represented by one data point on the graph. This default can be overridden within each metric definition. Default: cdk.Duration.seconds(300)
+        :param set_period_to_time_range: Whether to show the value from the entire time range. Only applicable for Bar and Pie charts. If false, values will be from the most recent period of your chosen time range; if true, shows the value from the entire time range. Default: false
+        :param show_units_in_label: Show the metrics units in the label column. Default: - false
+        :param start: The start of the time range to use for each widget independently from those of 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. Default: When the dashboard loads, the start time will be the default time range.
+        :param statistic: The default statistic to be displayed for each metric. This default can be overridden within the definition of each individual metric Default: - The statistic for each metric is used
+        :param summary: Properties for displaying summary columns. Default: - no summary columns are shown
+        :param thresholds: Thresholds for highlighting table cells. Default: - No thresholds
+
+        :exampleMetadata: infused
+
+        Example::
+
+            # dashboard: cloudwatch.Dashboard
+            
+            
+            dashboard.add_widgets(cloudwatch.TableWidget(
+                # ...
+            
+                layout=cloudwatch.TableLayout.VERTICAL
+            ))
+        '''
+        if isinstance(summary, dict):
+            summary = TableSummaryProps(**summary)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__03726ba90bb01c2a1340af4f73005fffe1b8288cff57d77f31d745d629defb8b)
+            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
+            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
+            check_type(argname="argument title", value=title, expected_type=type_hints["title"])
+            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
+            check_type(argname="argument end", value=end, expected_type=type_hints["end"])
+            check_type(argname="argument full_precision", value=full_precision, expected_type=type_hints["full_precision"])
+            check_type(argname="argument layout", value=layout, expected_type=type_hints["layout"])
+            check_type(argname="argument live_data", value=live_data, expected_type=type_hints["live_data"])
+            check_type(argname="argument metrics", value=metrics, expected_type=type_hints["metrics"])
+            check_type(argname="argument period", value=period, expected_type=type_hints["period"])
+            check_type(argname="argument set_period_to_time_range", value=set_period_to_time_range, expected_type=type_hints["set_period_to_time_range"])
+            check_type(argname="argument show_units_in_label", value=show_units_in_label, expected_type=type_hints["show_units_in_label"])
+            check_type(argname="argument start", value=start, expected_type=type_hints["start"])
+            check_type(argname="argument statistic", value=statistic, expected_type=type_hints["statistic"])
+            check_type(argname="argument summary", value=summary, expected_type=type_hints["summary"])
+            check_type(argname="argument thresholds", value=thresholds, expected_type=type_hints["thresholds"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if height is not None:
+            self._values["height"] = height
+        if region is not None:
+            self._values["region"] = region
+        if title is not None:
+            self._values["title"] = title
+        if width is not None:
+            self._values["width"] = width
+        if end is not None:
+            self._values["end"] = end
+        if full_precision is not None:
+            self._values["full_precision"] = full_precision
+        if layout is not None:
+            self._values["layout"] = layout
+        if live_data is not None:
+            self._values["live_data"] = live_data
+        if metrics is not None:
+            self._values["metrics"] = metrics
+        if period is not None:
+            self._values["period"] = period
+        if set_period_to_time_range is not None:
+            self._values["set_period_to_time_range"] = set_period_to_time_range
+        if show_units_in_label is not None:
+            self._values["show_units_in_label"] = show_units_in_label
+        if start is not None:
+            self._values["start"] = start
+        if statistic is not None:
+            self._values["statistic"] = statistic
+        if summary is not None:
+            self._values["summary"] = summary
+        if thresholds is not None:
+            self._values["thresholds"] = thresholds
+
+    @builtins.property
+    def height(self) -> typing.Optional[jsii.Number]:
+        '''Height of the widget.
+
+        :default:
+
+        - 6 for Alarm and Graph widgets.
+        3 for single value widgets where most recent value of a metric is displayed.
+        '''
+        result = self._values.get("height")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def region(self) -> typing.Optional[builtins.str]:
+        '''The region the metrics of this graph should be taken from.
+
+        :default: - Current region
+        '''
+        result = self._values.get("region")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def title(self) -> typing.Optional[builtins.str]:
+        '''Title for the graph.
+
+        :default: - None
+        '''
+        result = self._values.get("title")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def width(self) -> typing.Optional[jsii.Number]:
+        '''Width of the widget, in a grid of 24 units wide.
+
+        :default: 6
+        '''
+        result = self._values.get("width")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def end(self) -> typing.Optional[builtins.str]:
+        '''The end of the time range to use for each widget independently from those of the dashboard.
+
+        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.
+        '''
+        result = self._values.get("end")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def full_precision(self) -> typing.Optional[builtins.bool]:
+        '''Whether to show as many digits as can fit, before rounding.
+
+        :default: false
+        '''
+        result = self._values.get("full_precision")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def layout(self) -> typing.Optional[TableLayout]:
+        '''Table layout.
+
+        :default: - TableLayout.HORIZONTAL
+        '''
+        result = self._values.get("layout")
+        return typing.cast(typing.Optional[TableLayout], result)
+
+    @builtins.property
+    def live_data(self) -> typing.Optional[builtins.bool]:
+        '''Whether the graph should show live data.
+
+        :default: false
+        '''
+        result = self._values.get("live_data")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def metrics(self) -> typing.Optional[typing.List[IMetric]]:
+        '''Metrics to display in the table.
+
+        :default: - No metrics
+        '''
+        result = self._values.get("metrics")
+        return typing.cast(typing.Optional[typing.List[IMetric]], result)
+
+    @builtins.property
+    def period(self) -> typing.Optional[_Duration_4839e8c3]:
+        '''The default period for all metrics in this widget.
+
+        The period is the length of time represented by one data point on the graph.
+        This default can be overridden within each metric definition.
+
+        :default: cdk.Duration.seconds(300)
+        '''
+        result = self._values.get("period")
+        return typing.cast(typing.Optional[_Duration_4839e8c3], result)
+
+    @builtins.property
+    def set_period_to_time_range(self) -> typing.Optional[builtins.bool]:
+        '''Whether to show the value from the entire time range. Only applicable for Bar and Pie charts.
+
+        If false, values will be from the most recent period of your chosen time range;
+        if true, shows the value from the entire time range.
+
+        :default: false
+        '''
+        result = self._values.get("set_period_to_time_range")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def show_units_in_label(self) -> typing.Optional[builtins.bool]:
+        '''Show the metrics units in the label column.
+
+        :default: - false
+        '''
+        result = self._values.get("show_units_in_label")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def start(self) -> typing.Optional[builtins.str]:
+        '''The start of the time range to use for each widget independently from those of 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.
+
+        :default: When the dashboard loads, the start time will be the default time range.
+        '''
+        result = self._values.get("start")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def statistic(self) -> typing.Optional[builtins.str]:
+        '''The default statistic to be displayed for each metric.
+
+        This default can be overridden within the definition of each individual metric
+
+        :default: - The statistic for each metric is used
+        '''
+        result = self._values.get("statistic")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def summary(self) -> typing.Optional[TableSummaryProps]:
+        '''Properties for displaying summary columns.
+
+        :default: - no summary columns are shown
+        '''
+        result = self._values.get("summary")
+        return typing.cast(typing.Optional[TableSummaryProps], result)
+
+    @builtins.property
+    def thresholds(self) -> typing.Optional[typing.List[TableThreshold]]:
+        '''Thresholds for highlighting table cells.
+
+        :default: - No thresholds
+        '''
+        result = self._values.get("thresholds")
+        return typing.cast(typing.Optional[typing.List[TableThreshold]], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "TableWidgetProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.enum(jsii_type="aws-cdk-lib.aws_cloudwatch.TextWidgetBackground")
+class TextWidgetBackground(enum.Enum):
+    '''Background types available.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        # dashboard: cloudwatch.Dashboard
+        
+        
+        dashboard.add_widgets(cloudwatch.TextWidget(
+            markdown="# Key Performance Indicators",
+            background=cloudwatch.TextWidgetBackground.TRANSPARENT
+        ))
+    '''
+
+    SOLID = "SOLID"
+    '''Solid background.'''
+    TRANSPARENT = "TRANSPARENT"
+    '''Transparent background.'''
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_cloudwatch.TextWidgetProps",
+    jsii_struct_bases=[],
+    name_mapping={
+        "markdown": "markdown",
+        "background": "background",
+        "height": "height",
+        "width": "width",
+    },
+)
+class TextWidgetProps:
+    def __init__(
+        self,
+        *,
+        markdown: builtins.str,
+        background: typing.Optional[TextWidgetBackground] = None,
+        height: typing.Optional[jsii.Number] = None,
+        width: typing.Optional[jsii.Number] = None,
+    ) -> None:
+        '''Properties for a Text widget.
+
+        :param markdown: The text to display, in MarkDown format.
+        :param background: Background for the widget. Default: solid
+        :param height: Height of the widget. Default: 2
+        :param width: Width of the widget, in a grid of 24 units wide. Default: 6
+
+        :exampleMetadata: infused
+
+        Example::
+
+            # dashboard: cloudwatch.Dashboard
+            
+            
+            dashboard.add_widgets(cloudwatch.TextWidget(
+                markdown="# Key Performance Indicators"
+            ))
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__c678c9d6bdc1a1e852f5260a40406f2e09cfc10b899093e99e66b9998d086d5e)
+            check_type(argname="argument markdown", value=markdown, expected_type=type_hints["markdown"])
+            check_type(argname="argument background", value=background, expected_type=type_hints["background"])
+            check_type(argname="argument height", value=height, expected_type=type_hints["height"])
+            check_type(argname="argument width", value=width, expected_type=type_hints["width"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "markdown": markdown,
+        }
+        if background is not None:
+            self._values["background"] = background
+        if height is not None:
+            self._values["height"] = height
+        if width is not None:
+            self._values["width"] = width
+
+    @builtins.property
+    def markdown(self) -> builtins.str:
+        '''The text to display, in MarkDown format.'''
+        result = self._values.get("markdown")
+        assert result is not None, "Required property 'markdown' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def background(self) -> typing.Optional[TextWidgetBackground]:
+        '''Background for the widget.
+
+        :default: solid
+        '''
+        result = self._values.get("background")
+        return typing.cast(typing.Optional[TextWidgetBackground], result)
+
+    @builtins.property
+    def height(self) -> typing.Optional[jsii.Number]:
+        '''Height of the widget.
+
+        :default: 2
+        '''
+        result = self._values.get("height")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def width(self) -> typing.Optional[jsii.Number]:
+        '''Width of the widget, in a grid of 24 units wide.
+
+        :default: 6
+        '''
+        result = self._values.get("width")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "TextWidgetProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.enum(jsii_type="aws-cdk-lib.aws_cloudwatch.TreatMissingData")
+class TreatMissingData(enum.Enum):
+    '''Specify how missing data points are treated during alarm evaluation.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        import aws_cdk as cdk
+        import aws_cdk.aws_cloudwatch as cloudwatch
+        
+        
+        fn = lambda_.Function(self, "MyFunction",
+            runtime=lambda_.Runtime.NODEJS_18_X,
+            handler="index.handler",
+            code=lambda_.Code.from_asset(path.join(__dirname, "lambda-handler")),
+            timeout=Duration.minutes(5)
+        )
+        
+        if fn.timeout:
+            cloudwatch.Alarm(self, "MyAlarm",
+                metric=fn.metric_duration().with(
+                    statistic="Maximum"
+                ),
+                evaluation_periods=1,
+                datapoints_to_alarm=1,
+                threshold=fn.timeout.to_milliseconds(),
+                treat_missing_data=cloudwatch.TreatMissingData.IGNORE,
+                alarm_name="My Lambda Timeout"
+            )
+    '''
+
+    BREACHING = "BREACHING"
+    '''Missing data points are treated as breaching the threshold.'''
+    NOT_BREACHING = "NOT_BREACHING"
+    '''Missing data points are treated as being within the threshold.'''
+    IGNORE = "IGNORE"
+    '''The current alarm state is maintained.'''
+    MISSING = "MISSING"
+    '''The alarm does not consider missing data points when evaluating whether to change state.'''
+
+
+@jsii.enum(jsii_type="aws-cdk-lib.aws_cloudwatch.Unit")
+class Unit(enum.Enum):
+    '''Unit for metric.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        # log_group: logs.LogGroup
+        
+        mf = logs.MetricFilter(self, "MetricFilter",
+            log_group=log_group,
+            metric_namespace="MyApp",
+            metric_name="Latency",
+            filter_pattern=logs.FilterPattern.exists("$.latency"),
+            metric_value="$.latency",
+            dimensions={
+                "ErrorCode": "$.errorCode"
+            },
+            unit=cloudwatch.Unit.MILLISECONDS
+        )
+        
+        # expose a metric from the metric filter
+        metric = mf.metric()
+        
+        # you can use the metric to create a new alarm
+        cloudwatch.Alarm(self, "alarm from metric filter",
+            metric=metric,
+            threshold=100,
+            evaluation_periods=2
+        )
+    '''
 
     SECONDS = "SECONDS"
     '''Seconds.'''
@@ -13232,6 +13862,103 @@ class SingleValueWidget(
         return typing.cast(typing.List[typing.Any], jsii.invoke(self, "toJson", []))
 
 
+class TableWidget(
+    ConcreteWidget,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_cloudwatch.TableWidget",
+):
+    '''A dashboard widget that displays metrics.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        # dashboard: cloudwatch.Dashboard
+        
+        
+        dashboard.add_widgets(cloudwatch.TableWidget(
+            # ...
+        
+            layout=cloudwatch.TableLayout.VERTICAL
+        ))
+    '''
+
+    def __init__(
+        self,
+        *,
+        end: typing.Optional[builtins.str] = None,
+        full_precision: typing.Optional[builtins.bool] = None,
+        layout: typing.Optional[TableLayout] = None,
+        live_data: typing.Optional[builtins.bool] = None,
+        metrics: typing.Optional[typing.Sequence[IMetric]] = None,
+        period: typing.Optional[_Duration_4839e8c3] = None,
+        set_period_to_time_range: typing.Optional[builtins.bool] = None,
+        show_units_in_label: typing.Optional[builtins.bool] = None,
+        start: typing.Optional[builtins.str] = None,
+        statistic: typing.Optional[builtins.str] = None,
+        summary: typing.Optional[typing.Union[TableSummaryProps, typing.Dict[builtins.str, typing.Any]]] = None,
+        thresholds: typing.Optional[typing.Sequence[TableThreshold]] = None,
+        height: typing.Optional[jsii.Number] = None,
+        region: typing.Optional[builtins.str] = None,
+        title: typing.Optional[builtins.str] = None,
+        width: typing.Optional[jsii.Number] = None,
+    ) -> None:
+        '''
+        :param end: The end of the time range to use for each widget independently from those of the dashboard. 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.
+        :param full_precision: Whether to show as many digits as can fit, before rounding. Default: false
+        :param layout: Table layout. Default: - TableLayout.HORIZONTAL
+        :param live_data: Whether the graph should show live data. Default: false
+        :param metrics: Metrics to display in the table. Default: - No metrics
+        :param period: The default period for all metrics in this widget. The period is the length of time represented by one data point on the graph. This default can be overridden within each metric definition. Default: cdk.Duration.seconds(300)
+        :param set_period_to_time_range: Whether to show the value from the entire time range. Only applicable for Bar and Pie charts. If false, values will be from the most recent period of your chosen time range; if true, shows the value from the entire time range. Default: false
+        :param show_units_in_label: Show the metrics units in the label column. Default: - false
+        :param start: The start of the time range to use for each widget independently from those of 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. Default: When the dashboard loads, the start time will be the default time range.
+        :param statistic: The default statistic to be displayed for each metric. This default can be overridden within the definition of each individual metric Default: - The statistic for each metric is used
+        :param summary: Properties for displaying summary columns. Default: - no summary columns are shown
+        :param thresholds: Thresholds for highlighting table cells. Default: - No thresholds
+        :param height: Height of the widget. Default: - 6 for Alarm and Graph widgets. 3 for single value widgets where most recent value of a metric is displayed.
+        :param region: The region the metrics of this graph should be taken from. Default: - Current region
+        :param title: Title for the graph. Default: - None
+        :param width: Width of the widget, in a grid of 24 units wide. Default: 6
+        '''
+        props = TableWidgetProps(
+            end=end,
+            full_precision=full_precision,
+            layout=layout,
+            live_data=live_data,
+            metrics=metrics,
+            period=period,
+            set_period_to_time_range=set_period_to_time_range,
+            show_units_in_label=show_units_in_label,
+            start=start,
+            statistic=statistic,
+            summary=summary,
+            thresholds=thresholds,
+            height=height,
+            region=region,
+            title=title,
+            width=width,
+        )
+
+        jsii.create(self.__class__, self, [props])
+
+    @jsii.member(jsii_name="addMetric")
+    def add_metric(self, metric: IMetric) -> None:
+        '''Add another metric.
+
+        :param metric: the metric to add.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__14b284f52f62e4bb0b4243fb3b3bcaa2693e6ee107b2721f9467d31d81cf408b)
+            check_type(argname="argument metric", value=metric, expected_type=type_hints["metric"])
+        return typing.cast(None, jsii.invoke(self, "addMetric", [metric]))
+
+    @jsii.member(jsii_name="toJson")
+    def to_json(self) -> typing.List[typing.Any]:
+        '''Return the widget JSON for use in the dashboard.'''
+        return typing.cast(typing.List[typing.Any], jsii.invoke(self, "toJson", []))
+
+
 class TextWidget(
     ConcreteWidget,
     metaclass=jsii.JSIIMeta,
@@ -13977,6 +14704,12 @@ __all__ = [
     "SpacerProps",
     "Statistic",
     "Stats",
+    "TableLayout",
+    "TableSummaryColumn",
+    "TableSummaryProps",
+    "TableThreshold",
+    "TableWidget",
+    "TableWidgetProps",
     "TextWidget",
     "TextWidgetBackground",
     "TextWidgetProps",
@@ -15216,6 +15949,59 @@ def _typecheckingstub__1740e870895a9795d40caa429b748dd124ed575f6ae4335284294f422
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__98c18eab758ffae376ffa1675e2524ad60cd0a50fd033fe135c6d98d0f5d2692(
+    *,
+    columns: typing.Optional[typing.Sequence[TableSummaryColumn]] = None,
+    hide_non_summary_columns: typing.Optional[builtins.bool] = None,
+    sticky: typing.Optional[builtins.bool] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__70d2d8bf527174c0069d64738e83c5ebe4fd927ac2332ac0de67140546fb8616(
+    value: jsii.Number,
+    color: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__e6f92993218488cf545481e8167442910bb8b8c7c45aa7dfb6667808cb1077e6(
+    value: jsii.Number,
+    color: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__837fdebf81b3f53de6d99624ebde152b4aba1d764a0cc2bd930440701533924a(
+    lower_bound: jsii.Number,
+    upper_bound: jsii.Number,
+    color: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__03726ba90bb01c2a1340af4f73005fffe1b8288cff57d77f31d745d629defb8b(
+    *,
+    height: typing.Optional[jsii.Number] = None,
+    region: typing.Optional[builtins.str] = None,
+    title: typing.Optional[builtins.str] = None,
+    width: typing.Optional[jsii.Number] = None,
+    end: typing.Optional[builtins.str] = None,
+    full_precision: typing.Optional[builtins.bool] = None,
+    layout: typing.Optional[TableLayout] = None,
+    live_data: typing.Optional[builtins.bool] = None,
+    metrics: typing.Optional[typing.Sequence[IMetric]] = None,
+    period: typing.Optional[_Duration_4839e8c3] = None,
+    set_period_to_time_range: typing.Optional[builtins.bool] = None,
+    show_units_in_label: typing.Optional[builtins.bool] = None,
+    start: typing.Optional[builtins.str] = None,
+    statistic: typing.Optional[builtins.str] = None,
+    summary: typing.Optional[typing.Union[TableSummaryProps, typing.Dict[builtins.str, typing.Any]]] = None,
+    thresholds: typing.Optional[typing.Sequence[TableThreshold]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__c678c9d6bdc1a1e852f5260a40406f2e09cfc10b899093e99e66b9998d086d5e(
     *,
     markdown: builtins.str,
@@ -15411,6 +16197,12 @@ def _typecheckingstub__3471ad100c9e34a517506d76368276ef9b137a3c7b33aecc91910b5dc
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__14b284f52f62e4bb0b4243fb3b3bcaa2693e6ee107b2721f9467d31d81cf408b(
+    metric: IMetric,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__c8d51865c110b61caff6f389abfdbc4862eb4488d27c9b39083e0293fd0be343(
     x: jsii.Number,
     y: jsii.Number,