terraconstructs 0.0.8

package/lib/aws/cloudwatch/metric-types.js

@@ -0,0 +1,151 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-cloudwatch/lib/metric-types.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Unit = exports.Statistic = void 0;
+/**
+ * Statistic to use over the aggregation period
+ *
+ * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Statistics-definitions.html
+ * @deprecated Use one of the factory methods on `Stats` to produce statistics strings
+ */
+var Statistic;
+(function (Statistic) {
+    /**
+     * The count (number) of data points used for the statistical calculation.
+     */
+    Statistic["SAMPLE_COUNT"] = "SampleCount";
+    /**
+     * The value of Sum / SampleCount during the specified period.
+     */
+    Statistic["AVERAGE"] = "Average";
+    /**
+     * All values submitted for the matching metric added together.
+     * This statistic can be useful for determining the total volume of a metric.
+     */
+    Statistic["SUM"] = "Sum";
+    /**
+     * The lowest value observed during the specified period.
+     * You can use this value to determine low volumes of activity for your application.
+     */
+    Statistic["MINIMUM"] = "Minimum";
+    /**
+     * The highest value observed during the specified period.
+     * You can use this value to determine high volumes of activity for your application.
+     */
+    Statistic["MAXIMUM"] = "Maximum";
+})(Statistic || (exports.Statistic = Statistic = {}));
+/**
+ * Unit for metric
+ */
+var Unit;
+(function (Unit) {
+    /**
+     * Seconds
+     */
+    Unit["SECONDS"] = "Seconds";
+    /**
+     * Microseconds
+     */
+    Unit["MICROSECONDS"] = "Microseconds";
+    /**
+     * Milliseconds
+     */
+    Unit["MILLISECONDS"] = "Milliseconds";
+    /**
+     * Bytes
+     */
+    Unit["BYTES"] = "Bytes";
+    /**
+     * Kilobytes
+     */
+    Unit["KILOBYTES"] = "Kilobytes";
+    /**
+     * Megabytes
+     */
+    Unit["MEGABYTES"] = "Megabytes";
+    /**
+     * Gigabytes
+     */
+    Unit["GIGABYTES"] = "Gigabytes";
+    /**
+     * Terabytes
+     */
+    Unit["TERABYTES"] = "Terabytes";
+    /**
+     * Bits
+     */
+    Unit["BITS"] = "Bits";
+    /**
+     * Kilobits
+     */
+    Unit["KILOBITS"] = "Kilobits";
+    /**
+     * Megabits
+     */
+    Unit["MEGABITS"] = "Megabits";
+    /**
+     * Gigabits
+     */
+    Unit["GIGABITS"] = "Gigabits";
+    /**
+     * Terabits
+     */
+    Unit["TERABITS"] = "Terabits";
+    /**
+     * Percent
+     */
+    Unit["PERCENT"] = "Percent";
+    /**
+     * Count
+     */
+    Unit["COUNT"] = "Count";
+    /**
+     * Bytes/second (B/s)
+     */
+    Unit["BYTES_PER_SECOND"] = "Bytes/Second";
+    /**
+     * Kilobytes/second (kB/s)
+     */
+    Unit["KILOBYTES_PER_SECOND"] = "Kilobytes/Second";
+    /**
+     * Megabytes/second (MB/s)
+     */
+    Unit["MEGABYTES_PER_SECOND"] = "Megabytes/Second";
+    /**
+     * Gigabytes/second (GB/s)
+     */
+    Unit["GIGABYTES_PER_SECOND"] = "Gigabytes/Second";
+    /**
+     * Terabytes/second (TB/s)
+     */
+    Unit["TERABYTES_PER_SECOND"] = "Terabytes/Second";
+    /**
+     * Bits/second (b/s)
+     */
+    Unit["BITS_PER_SECOND"] = "Bits/Second";
+    /**
+     * Kilobits/second (kb/s)
+     */
+    Unit["KILOBITS_PER_SECOND"] = "Kilobits/Second";
+    /**
+     * Megabits/second (Mb/s)
+     */
+    Unit["MEGABITS_PER_SECOND"] = "Megabits/Second";
+    /**
+     * Gigabits/second (Gb/s)
+     */
+    Unit["GIGABITS_PER_SECOND"] = "Gigabits/Second";
+    /**
+     * Terabits/second (Tb/s)
+     */
+    Unit["TERABITS_PER_SECOND"] = "Terabits/Second";
+    /**
+     * Count/second
+     */
+    Unit["COUNT_PER_SECOND"] = "Count/Second";
+    /**
+     * None
+     */
+    Unit["NONE"] = "None";
+})(Unit || (exports.Unit = Unit = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metric-types.js","sourceRoot":"","sources":["../../../src/aws/cloudwatch/metric-types.ts"],"names":[],"mappings":";AAAA,uGAAuG;;;AA+CvG;;;;;GAKG;AACH,IAAY,SAyBX;AAzBD,WAAY,SAAS;IACnB;;OAEG;IACH,yCAA4B,CAAA;IAE5B;;OAEG;IACH,gCAAmB,CAAA;IACnB;;;OAGG;IACH,wBAAW,CAAA;IACX;;;OAGG;IACH,gCAAmB,CAAA;IACnB;;;OAGG;IACH,gCAAmB,CAAA;AACrB,CAAC,EAzBW,SAAS,yBAAT,SAAS,QAyBpB;AAED;;GAEG;AACH,IAAY,IAuIX;AAvID,WAAY,IAAI;IACd;;OAEG;IACH,2BAAmB,CAAA;IAEnB;;OAEG;IACH,qCAA6B,CAAA;IAE7B;;OAEG;IACH,qCAA6B,CAAA;IAE7B;;OAEG;IACH,uBAAe,CAAA;IAEf;;OAEG;IACH,+BAAuB,CAAA;IAEvB;;OAEG;IACH,+BAAuB,CAAA;IAEvB;;OAEG;IACH,+BAAuB,CAAA;IAEvB;;OAEG;IACH,+BAAuB,CAAA;IAEvB;;OAEG;IACH,qBAAa,CAAA;IAEb;;OAEG;IACH,6BAAqB,CAAA;IAErB;;OAEG;IACH,6BAAqB,CAAA;IAErB;;OAEG;IACH,6BAAqB,CAAA;IAErB;;OAEG;IACH,6BAAqB,CAAA;IAErB;;OAEG;IACH,2BAAmB,CAAA;IAEnB;;OAEG;IACH,uBAAe,CAAA;IAEf;;OAEG;IACH,yCAAiC,CAAA;IAEjC;;OAEG;IACH,iDAAyC,CAAA;IAEzC;;OAEG;IACH,iDAAyC,CAAA;IAEzC;;OAEG;IACH,iDAAyC,CAAA;IAEzC;;OAEG;IACH,iDAAyC,CAAA;IAEzC;;OAEG;IACH,uCAA+B,CAAA;IAE/B;;OAEG;IACH,+CAAuC,CAAA;IAEvC;;OAEG;IACH,+CAAuC,CAAA;IAEvC;;OAEG;IACH,+CAAuC,CAAA;IAEvC;;OAEG;IACH,+CAAuC,CAAA;IAEvC;;OAEG;IACH,yCAAiC,CAAA;IAEjC;;OAEG;IACH,qBAAa,CAAA;AACf,CAAC,EAvIW,IAAI,oBAAJ,IAAI,QAuIf","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-cloudwatch/lib/metric-types.ts\n\nimport { Duration } from \"../../duration\";\n\n/**\n * Interface for metrics\n */\nexport interface IMetric {\n  /**\n   * Any warnings related to this metric\n   *\n   * Should be attached to the consuming construct.\n   *\n   * @default - None\n   * @deprecated - use warningsV2\n   */\n  readonly warnings?: string[];\n\n  /**\n   * Any warnings related to this metric\n   *\n   * Should be attached to the consuming construct.\n   *\n   * @default - None\n   */\n  readonly warningsV2?: { [id: string]: string };\n\n  /**\n   * Inspect the details of the metric object\n   */\n  toMetricConfig(): MetricConfig;\n\n  /**\n   * Turn this metric object into an alarm configuration\n   *\n   * @deprecated Use `toMetricConfig()` instead.\n   */\n  toAlarmConfig(): MetricAlarmConfig;\n\n  /**\n   * Turn this metric object into a graph configuration\n   *\n   * @deprecated Use `toMetricConfig()` instead.\n   */\n  toGraphConfig(): MetricGraphConfig;\n}\n\n/**\n * Statistic to use over the aggregation period\n *\n * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Statistics-definitions.html\n * @deprecated Use one of the factory methods on `Stats` to produce statistics strings\n */\nexport enum Statistic {\n  /**\n   * The count (number) of data points used for the statistical calculation.\n   */\n  SAMPLE_COUNT = \"SampleCount\",\n\n  /**\n   * The value of Sum / SampleCount during the specified period.\n   */\n  AVERAGE = \"Average\",\n  /**\n   * All values submitted for the matching metric added together.\n   * This statistic can be useful for determining the total volume of a metric.\n   */\n  SUM = \"Sum\",\n  /**\n   * The lowest value observed during the specified period.\n   * You can use this value to determine low volumes of activity for your application.\n   */\n  MINIMUM = \"Minimum\",\n  /**\n   * The highest value observed during the specified period.\n   * You can use this value to determine high volumes of activity for your application.\n   */\n  MAXIMUM = \"Maximum\",\n}\n\n/**\n * Unit for metric\n */\nexport enum Unit {\n  /**\n   * Seconds\n   */\n  SECONDS = \"Seconds\",\n\n  /**\n   * Microseconds\n   */\n  MICROSECONDS = \"Microseconds\",\n\n  /**\n   * Milliseconds\n   */\n  MILLISECONDS = \"Milliseconds\",\n\n  /**\n   * Bytes\n   */\n  BYTES = \"Bytes\",\n\n  /**\n   * Kilobytes\n   */\n  KILOBYTES = \"Kilobytes\",\n\n  /**\n   * Megabytes\n   */\n  MEGABYTES = \"Megabytes\",\n\n  /**\n   * Gigabytes\n   */\n  GIGABYTES = \"Gigabytes\",\n\n  /**\n   * Terabytes\n   */\n  TERABYTES = \"Terabytes\",\n\n  /**\n   * Bits\n   */\n  BITS = \"Bits\",\n\n  /**\n   * Kilobits\n   */\n  KILOBITS = \"Kilobits\",\n\n  /**\n   * Megabits\n   */\n  MEGABITS = \"Megabits\",\n\n  /**\n   * Gigabits\n   */\n  GIGABITS = \"Gigabits\",\n\n  /**\n   * Terabits\n   */\n  TERABITS = \"Terabits\",\n\n  /**\n   * Percent\n   */\n  PERCENT = \"Percent\",\n\n  /**\n   * Count\n   */\n  COUNT = \"Count\",\n\n  /**\n   * Bytes/second (B/s)\n   */\n  BYTES_PER_SECOND = \"Bytes/Second\",\n\n  /**\n   * Kilobytes/second (kB/s)\n   */\n  KILOBYTES_PER_SECOND = \"Kilobytes/Second\",\n\n  /**\n   * Megabytes/second (MB/s)\n   */\n  MEGABYTES_PER_SECOND = \"Megabytes/Second\",\n\n  /**\n   * Gigabytes/second (GB/s)\n   */\n  GIGABYTES_PER_SECOND = \"Gigabytes/Second\",\n\n  /**\n   * Terabytes/second (TB/s)\n   */\n  TERABYTES_PER_SECOND = \"Terabytes/Second\",\n\n  /**\n   * Bits/second (b/s)\n   */\n  BITS_PER_SECOND = \"Bits/Second\",\n\n  /**\n   * Kilobits/second (kb/s)\n   */\n  KILOBITS_PER_SECOND = \"Kilobits/Second\",\n\n  /**\n   * Megabits/second (Mb/s)\n   */\n  MEGABITS_PER_SECOND = \"Megabits/Second\",\n\n  /**\n   * Gigabits/second (Gb/s)\n   */\n  GIGABITS_PER_SECOND = \"Gigabits/Second\",\n\n  /**\n   * Terabits/second (Tb/s)\n   */\n  TERABITS_PER_SECOND = \"Terabits/Second\",\n\n  /**\n   * Count/second\n   */\n  COUNT_PER_SECOND = \"Count/Second\",\n\n  /**\n   * None\n   */\n  NONE = \"None\",\n}\n\n/**\n * Properties of a rendered metric\n */\nexport interface MetricConfig {\n  /**\n   * In case the metric represents a query, the details of the query\n   *\n   * @default - None\n   */\n  readonly metricStat?: MetricStatConfig;\n\n  /**\n   * In case the metric is a math expression, the details of the math expression\n   *\n   * @default - None\n   */\n  readonly mathExpression?: MetricExpressionConfig;\n\n  /**\n   * Additional properties which will be rendered if the metric is used in a dashboard\n   *\n   * Examples are 'label' and 'color', but any key in here will be\n   * added to dashboard graphs.\n   *\n   * @default - None\n   */\n  readonly renderingProperties?: Record<string, unknown>;\n}\n\n/**\n * Properties for a concrete metric\n *\n * NOTE: `unit` is no longer on this object since it is only used for `Alarms`, and doesn't mean what one\n * would expect it to mean there anyway. It is most likely to be misused.\n */\nexport interface MetricStatConfig {\n  /**\n   * The dimensions to apply to the alarm\n   *\n   * @default {}\n   */\n  readonly dimensions?: Record<string, string>;\n\n  /**\n   * Namespace of the metric\n   */\n  readonly namespace: string;\n\n  /**\n   * Name of the metric\n   */\n  readonly metricName: string;\n\n  /**\n   * How many seconds to aggregate over\n   */\n  readonly period: Duration;\n\n  /**\n   * Aggregation function to use (can be either simple or a percentile)\n   */\n  readonly statistic: string;\n\n  /**\n   * Unit used to filter the metric stream\n   *\n   * Only refer to datums emitted to the metric stream with the given unit and\n   * ignore all others. Only useful when datums are being emitted to the same\n   * metric stream under different units.\n   *\n   * This field has been renamed from plain `unit` to clearly communicate\n   * its purpose.\n   *\n   * @default - Refer to all metric datums\n   */\n  readonly unitFilter?: Unit;\n\n  /**\n   * Region which this metric comes from.\n   *\n   * @default Deployment region.\n   */\n  readonly region?: string;\n\n  /**\n   * Account which this metric comes from.\n   *\n   * @default Deployment account.\n   */\n  readonly account?: string;\n}\n\n/**\n * Properties for a concrete metric\n */\nexport interface MetricExpressionConfig {\n  /**\n   * Math expression for the metric.\n   */\n  readonly expression: string;\n\n  /**\n   * Metrics used in the math expression\n   */\n  readonly usingMetrics: Record<string, IMetric>;\n\n  /**\n   * How many seconds to aggregate over\n   */\n  readonly period: number;\n\n  /**\n   * Account to evaluate search expressions within.\n   *\n   * @default - Deployment account.\n   */\n  readonly searchAccount?: string;\n\n  /**\n   * Region to evaluate search expressions within.\n   *\n   * @default - Deployment region.\n   */\n  readonly searchRegion?: string;\n}\n\n/**\n * Properties used to construct the Metric identifying part of an Alarm\n *\n * @deprecated Replaced by MetricConfig\n */\nexport interface MetricAlarmConfig {\n  /**\n   * The dimensions to apply to the alarm\n   */\n  readonly dimensions?: Record<string, string>;\n\n  /**\n   * Namespace of the metric\n   */\n  readonly namespace: string;\n\n  /**\n   * Name of the metric\n   */\n  readonly metricName: string;\n\n  /**\n   * How many seconds to aggregate over\n   */\n  readonly period: number;\n\n  /**\n   * Simple aggregation function to use\n   */\n  readonly statistic?: Statistic;\n\n  /**\n   * Percentile aggregation function to use\n   */\n  readonly extendedStatistic?: string;\n\n  /**\n   * The unit of the alarm\n   */\n  readonly unit?: Unit;\n}\n\n/**\n * Properties used to construct the Metric identifying part of a Graph\n *\n * @deprecated Replaced by MetricConfig\n */\nexport interface MetricGraphConfig {\n  /**\n   * The dimensions to apply to the alarm\n   */\n  readonly dimensions?: Record<string, unknown>;\n\n  /**\n   * Namespace of the metric\n   */\n  readonly namespace: string;\n\n  /**\n   * Name of the metric\n   */\n  readonly metricName: string;\n\n  /**\n   * Rendering properties override yAxis parameter of the widget object\n   */\n  readonly renderingProperties: MetricRenderingProperties;\n\n  /**\n   * How many seconds to aggregate over\n   *\n   * @deprecated Use `period` in `renderingProperties`\n   */\n  readonly period: number;\n\n  /**\n   * Label for the metric\n   *\n   * @deprecated Use `label` in `renderingProperties`\n   */\n  readonly label?: string;\n\n  /**\n   * Color for the graph line\n   *\n   * @deprecated Use `color` in `renderingProperties`\n   */\n  readonly color?: string;\n\n  /**\n   * Aggregation function to use (can be either simple or a percentile)\n   *\n   * @deprecated Use `stat` in `renderingProperties`\n   */\n  readonly statistic?: string;\n\n  /**\n   * The unit of the alarm\n   *\n   * @deprecated not used in dashboard widgets\n   */\n  readonly unit?: Unit;\n}\n\n/**\n * Custom rendering properties that override the default rendering properties specified in the yAxis parameter of the widget object.\n *\n * @deprecated Replaced by MetricConfig.\n */\nexport interface MetricRenderingProperties {\n  /**\n   * How many seconds to aggregate over\n   */\n  readonly period: number;\n\n  /**\n   * Label for the metric\n   */\n  readonly label?: string;\n\n  /**\n   * The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph.\n   * The `Color` class has a set of standard colors that can be used here.\n   */\n  readonly color?: string;\n\n  /**\n   * Aggregation function to use (can be either simple or a percentile)\n   */\n  readonly stat?: string;\n}\n"]}

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

@@ -0,0 +1,492 @@
+import { Construct, IConstruct } from "constructs";
+import { Alarm, ComparisonOperator, TreatMissingData } from "./alarm";
+import { IMetric, MetricAlarmConfig, MetricConfig, MetricGraphConfig, Unit } from "./metric-types";
+import { Duration } from "../../duration";
+import * as iam from "../iam";
+export type DimensionsMap = {
+    [dim: string]: string;
+};
+/**
+ * Options shared by most methods accepting metric options
+ */
+export interface CommonMetricOptions {
+    /**
+     * The period over which the specified statistic is applied.
+     *
+     * @default Duration.minutes(5)
+     */
+    readonly period?: Duration;
+    /**
+     * What function to use for aggregating.
+     *
+     * Use the `aws_cloudwatch.Stats` helper class to construct valid input strings.
+     *
+     * Can be one of the following:
+     *
+     * - "Minimum" | "min"
+     * - "Maximum" | "max"
+     * - "Average" | "avg"
+     * - "Sum" | "sum"
+     * - "SampleCount | "n"
+     * - "pNN.NN"
+     * - "tmNN.NN" | "tm(NN.NN%:NN.NN%)"
+     * - "iqm"
+     * - "wmNN.NN" | "wm(NN.NN%:NN.NN%)"
+     * - "tcNN.NN" | "tc(NN.NN%:NN.NN%)"
+     * - "tsNN.NN" | "ts(NN.NN%:NN.NN%)"
+     *
+     * @default Average
+     */
+    readonly statistic?: string;
+    /**
+     * Dimensions of the metric
+     *
+     * @default - No dimensions.
+     */
+    readonly dimensionsMap?: DimensionsMap;
+    /**
+     * Unit used to filter the metric stream
+     *
+     * Only refer to datums emitted to the metric stream with the given unit and
+     * ignore all others. Only useful when datums are being emitted to the same
+     * metric stream under different units.
+     *
+     * The default is to use all matric datums in the stream, regardless of unit,
+     * which is recommended in nearly all cases.
+     *
+     * CloudWatch does not honor this property for graphs.
+     *
+     * @default - All metric datums in the given metric stream
+     */
+    readonly unit?: Unit;
+    /**
+     * Label for this metric when added to a Graph in a Dashboard
+     *
+     * You can use [dynamic labels](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html)
+     * to show summary information about the entire displayed time series
+     * in the legend. For example, if you use:
+     *
+     * ```
+     * [max: ${MAX}] MyMetric
+     * ```
+     *
+     * As the metric label, the maximum value in the visible range will
+     * be shown next to the time series name in the graph's legend.
+     *
+     * @default - No label
+     */
+    readonly label?: string;
+    /**
+     * The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph.
+     * The `Color` class has a set of standard colors that can be used here.
+     * @default - Automatic color
+     */
+    readonly color?: string;
+    /**
+     * Account which this metric comes from.
+     *
+     * @default - Deployment account.
+     */
+    readonly account?: string;
+    /**
+     * Region which this metric comes from.
+     *
+     * @default - Deployment region.
+     */
+    readonly region?: string;
+}
+/**
+ * Properties for a metric
+ */
+export interface MetricProps extends CommonMetricOptions {
+    /**
+     * Namespace of the metric.
+     */
+    readonly namespace: string;
+    /**
+     * Name of the metric.
+     */
+    readonly metricName: string;
+}
+/**
+ * Properties of a metric that can be changed
+ */
+export interface MetricOptions extends CommonMetricOptions {
+}
+/**
+ * Configurable options for MathExpressions
+ */
+export interface MathExpressionOptions {
+    /**
+     * Label for this expression when added to a Graph in a Dashboard
+     *
+     * If this expression evaluates to more than one time series (for
+     * example, through the use of `METRICS()` or `SEARCH()` expressions),
+     * each time series will appear in the graph using a combination of the
+     * expression label and the individual metric label. Specify the empty
+     * string (`''`) to suppress the expression label and only keep the
+     * metric label.
+     *
+     * You can use [dynamic labels](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html)
+     * to show summary information about the displayed time series
+     * in the legend. For example, if you use:
+     *
+     * ```
+     * [max: ${MAX}] MyMetric
+     * ```
+     *
+     * As the metric label, the maximum value in the visible range will
+     * be shown next to the time series name in the graph's legend. If the
+     * math expression produces more than one time series, the maximum
+     * will be shown for each individual time series produce by this
+     * math expression.
+     *
+     * @default - Expression value is used as label
+     */
+    readonly label?: string;
+    /**
+     * Color for this metric when added to a Graph in a Dashboard
+     *
+     * @default - Automatic color
+     */
+    readonly color?: string;
+    /**
+     * The period over which the expression's statistics are applied.
+     *
+     * This period overrides all periods in the metrics used in this
+     * math expression.
+     *
+     * @default Duration.minutes(5)
+     */
+    readonly period?: Duration;
+    /**
+     * Account to evaluate search expressions within.
+     *
+     * Specifying a searchAccount has no effect to the account used
+     * for metrics within the expression (passed via usingMetrics).
+     *
+     * @default - Deployment account.
+     */
+    readonly searchAccount?: string;
+    /**
+     * Region to evaluate search expressions within.
+     *
+     * Specifying a searchRegion has no effect to the region used
+     * for metrics within the expression (passed via usingMetrics).
+     *
+     * @default - Deployment region.
+     */
+    readonly searchRegion?: string;
+}
+/**
+ * Properties for a MathExpression
+ */
+export interface MathExpressionProps extends MathExpressionOptions {
+    /**
+     * The expression defining the metric.
+     *
+     * When an expression contains a SEARCH function, it cannot be used
+     * within an Alarm.
+     */
+    readonly expression: string;
+    /**
+     * The metrics used in the expression, in a map.
+     *
+     * The key is the identifier that represents the given metric in the
+     * expression, and the value is the actual Metric object.
+     *
+     * The `period` of each metric in `usingMetrics` is ignored and instead overridden
+     * by the `period` specified for the `MathExpression` construct. Even if no `period`
+     * is specified for the `MathExpression`, it will be overridden by the default
+     * value (`Duration.minutes(5)`).
+     *
+     * Example:
+     *
+     * ```ts
+     * declare const metrics: elbv2.IApplicationLoadBalancerMetrics;
+     * new cloudwatch.MathExpression({
+     *   expression:  'm1+m2',
+     *   label: 'AlbErrors',
+     *   usingMetrics: {
+     *     m1: metrics.custom('HTTPCode_ELB_500_Count', {
+     *       period: Duration.minutes(1), // <- This period will be ignored
+     *       statistic: 'Sum',
+     *       label: 'HTTPCode_ELB_500_Count',
+     *     }),
+     *     m2: metrics.custom('HTTPCode_ELB_502_Count', {
+     *       period: Duration.minutes(1), // <- This period will be ignored
+     *       statistic: 'Sum',
+     *       label: 'HTTPCode_ELB_502_Count',
+     *     }),
+     *   },
+     *   period: Duration.minutes(3), // <- This overrides the period of each metric in `usingMetrics`
+     *                                //    (Even if not specified, it is overridden by the default value)
+     * });
+     * ```
+     *
+     * @default - Empty map.
+     */
+    readonly usingMetrics?: Record<string, IMetric>;
+}
+/**
+ * A metric emitted by a service
+ *
+ * The metric is a combination of a metric identifier (namespace, name and dimensions)
+ * and an aggregation function (statistic, period and unit).
+ *
+ * It also contains metadata which is used only in graphs, such as color and label.
+ * It makes sense to embed this in here, so that compound constructs can attach
+ * that metadata to metrics they expose.
+ *
+ * This class does not represent a resource, so hence is not a construct. Instead,
+ * Metric is an abstraction that makes it easy to specify metrics for use in both
+ * alarms and graphs.
+ */
+export declare class Metric implements IMetric {
+    /**
+     * Grant permissions to the given identity to write metrics.
+     *
+     * @param grantee The IAM identity to give permissions to.
+     */
+    static grantPutMetricData(grantee: iam.IGrantable): iam.Grant;
+    /** Dimensions of this metric */
+    readonly dimensions?: DimensionsMap;
+    /** Namespace of this metric */
+    readonly namespace: string;
+    /** Name of this metric */
+    readonly metricName: string;
+    /** Period of this metric */
+    readonly period: Duration;
+    /** Statistic of this metric */
+    readonly statistic: string;
+    /** Label for this metric when added to a Graph in a Dashboard */
+    readonly label?: string;
+    /** The hex color code used when this metric is rendered on a graph. */
+    readonly color?: string;
+    /** Unit of the metric. */
+    readonly unit?: Unit;
+    /** Account which this metric comes from */
+    readonly account?: string;
+    /** Region which this metric comes from. */
+    readonly region?: string;
+    /**
+     * Warnings attached to this metric.
+     * @deprecated - use warningsV2
+     **/
+    readonly warnings?: string[];
+    /** Warnings attached to this metric. */
+    readonly warningsV2?: {
+        [id: string]: string;
+    };
+    constructor(props: MetricProps);
+    /**
+     * Return a copy of Metric `with` properties changed.
+     *
+     * All properties except namespace and metricName can be changed.
+     *
+     * @param props The set of properties to change.
+     */
+    with(props: MetricOptions): Metric;
+    /**
+     * Attach the metric object to the given construct scope
+     *
+     * Returns a Metric object that uses the account and region from the Stack
+     * the given construct is defined in. If the metric is subsequently used
+     * in a Dashboard or Alarm in a different Stack defined in a different
+     * account or region, the appropriate 'region' and 'account' fields
+     * will be added to it.
+     *
+     * If the scope we attach to is in an environment-agnostic stack,
+     * nothing is done and the same Metric object is returned.
+     */
+    attachTo(scope: IConstruct): Metric;
+    toMetricConfig(): MetricConfig;
+    /** @deprecated use toMetricConfig() */
+    toAlarmConfig(): MetricAlarmConfig;
+    /**
+     * @deprecated use toMetricConfig()
+     */
+    toGraphConfig(): MetricGraphConfig;
+    /**
+     * Make a new Alarm for this metric
+     *
+     * Combines both properties that may adjust the metric (aggregation) as well
+     * as alarm properties.
+     */
+    createAlarm(scope: Construct, id: string, props: CreateAlarmOptions): Alarm;
+    toString(): string;
+    private validateDimensions;
+}
+/**
+ * A math expression built with metric(s) emitted by a service
+ *
+ * The math expression is a combination of an expression (x+y) and metrics to apply expression on.
+ * It also contains metadata which is used only in graphs, such as color and label.
+ * It makes sense to embed this in here, so that compound constructs can attach
+ * that metadata to metrics they expose.
+ *
+ * MathExpression can also be used for search expressions. In this case,
+ * it also optionally accepts a searchRegion and searchAccount property for cross-environment
+ * search expressions.
+ *
+ * This class does not represent a resource, so hence is not a construct. Instead,
+ * MathExpression is an abstraction that makes it easy to specify metrics for use in both
+ * alarms and graphs.
+ */
+export declare class MathExpression implements IMetric {
+    /**
+     * The expression defining the metric.
+     */
+    readonly expression: string;
+    /**
+     * The metrics used in the expression as KeyValuePair <id, metric>.
+     */
+    readonly usingMetrics: Record<string, IMetric>;
+    /**
+     * Label for this metric when added to a Graph.
+     */
+    readonly label?: string;
+    /**
+     * The hex color code, prefixed with '#' (e.g. '#00ff00'), to use when this metric is rendered on a graph.
+     * The `Color` class has a set of standard colors that can be used here.
+     */
+    readonly color?: string;
+    /**
+     * Aggregation period of this metric
+     */
+    readonly period: Duration;
+    /**
+     * Account to evaluate search expressions within.
+     */
+    readonly searchAccount?: string;
+    /**
+     * Region to evaluate search expressions within.
+     */
+    readonly searchRegion?: string;
+    /**
+     * Warnings generated by this math expression
+     * @deprecated - use warningsV2
+     */
+    readonly warnings?: string[];
+    /**
+     * Warnings generated by this math expression
+     */
+    readonly warningsV2?: {
+        [id: string]: string;
+    };
+    constructor(props: MathExpressionProps);
+    /**
+     * Return a copy of Metric with properties changed.
+     *
+     * All properties except namespace and metricName can be changed.
+     *
+     * @param props The set of properties to change.
+     */
+    with(props: MathExpressionOptions): MathExpression;
+    /**
+     * @deprecated use toMetricConfig()
+     */
+    toAlarmConfig(): MetricAlarmConfig;
+    /**
+     * @deprecated use toMetricConfig()
+     */
+    toGraphConfig(): MetricGraphConfig;
+    toMetricConfig(): MetricConfig;
+    /**
+     * Make a new Alarm for this metric
+     *
+     * Combines both properties that may adjust the metric (aggregation) as well
+     * as alarm properties.
+     */
+    createAlarm(scope: Construct, id: string, props: CreateAlarmOptions): Alarm;
+    toString(): string;
+    private validateNoIdConflicts;
+}
+/**
+ * Properties needed to make an alarm from a metric
+ */
+export interface CreateAlarmOptions {
+    /**
+     * The period over which the specified statistic is applied.
+     *
+     * Cannot be used with `MathExpression` objects.
+     *
+     * @default - The period from the metric
+     * @deprecated Use `metric.with({ period: ... })` to encode the period into the Metric object
+     */
+    readonly period?: Duration;
+    /**
+     * What function to use for aggregating.
+     *
+     * Can be one of the following:
+     *
+     * - "Minimum" | "min"
+     * - "Maximum" | "max"
+     * - "Average" | "avg"
+     * - "Sum" | "sum"
+     * - "SampleCount | "n"
+     * - "pNN.NN"
+     *
+     * Cannot be used with `MathExpression` objects.
+     *
+     * @default - The statistic from the metric
+     * @deprecated Use `metric.with({ statistic: ... })` to encode the period into the Metric object
+     */
+    readonly statistic?: string;
+    /**
+     * Name of the alarm
+     *
+     * @default Automatically generated name
+     */
+    readonly alarmName?: string;
+    /**
+     * Description for the alarm
+     *
+     * @default No description
+     */
+    readonly alarmDescription?: string;
+    /**
+     * Comparison to use to check if metric is breaching
+     *
+     * @default GreaterThanOrEqualToThreshold
+     */
+    readonly comparisonOperator?: ComparisonOperator;
+    /**
+     * The value against which the specified statistic is compared.
+     */
+    readonly threshold: number;
+    /**
+     * The number of periods over which data is compared to the specified threshold.
+     */
+    readonly evaluationPeriods: number;
+    /**
+     * Specifies whether to evaluate the data and potentially change the alarm state if there are too few data points to be statistically significant.
+     *
+     * Used only for alarms that are based on percentiles.
+     *
+     * @default - Not configured.
+     */
+    readonly evaluateLowSampleCountPercentile?: string;
+    /**
+     * Sets how this alarm is to handle missing data points.
+     *
+     * @default TreatMissingData.Missing
+     */
+    readonly treatMissingData?: TreatMissingData;
+    /**
+     * Whether the actions for this alarm are enabled
+     *
+     * @default true
+     */
+    readonly actionsEnabled?: boolean;
+    /**
+     * The number of datapoints that must be breaching to trigger the alarm. This is used only if you are setting an "M
+     * out of N" alarm. In that case, this value is the M. For more information, see Evaluating an Alarm in the Amazon
+     * CloudWatch User Guide.
+     *
+     * @default ``evaluationPeriods``
+     *
+     * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html#alarm-evaluation
+     */
+    readonly datapointsToAlarm?: number;
+}