@aws-cdk/metrics-facade-alpha 2.261.0-alpha.0

package/lib/services/aws-ec2/metrics.generated.js

@@ -0,0 +1,2434 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VPNMetrics = exports.TransitGatewayMetrics = exports.NATGatewayMetrics = exports.CWAgentMetrics = exports.EC2Metrics = exports.EBSMetrics = exports.EC2CapacityReservationsMetrics = void 0;
+/* eslint-disable @stylistic/max-len, eol-last */
+const cloudwatch = __importStar(require("aws-cdk-lib/aws-cloudwatch"));
+/**
+ * CloudWatch metrics facade for AWS/EC2CapacityReservations
+ * This class contains helper functions to initialize the dimension-sets classes
+ * for selected resources if available.
+ *
+ * @stability external
+ */
+class EC2CapacityReservationsMetrics {
+    /**
+     * Create CapacityReservationMetrics from a CapacityReservation reference
+     */
+    static fromCapacityReservation(ref) {
+        return new EC2CapacityReservationsMetrics.CapacityReservationMetrics({
+            capacityReservationId: ref.capacityReservationRef.capacityReservationId
+        });
+    }
+}
+exports.EC2CapacityReservationsMetrics = EC2CapacityReservationsMetrics;
+(function (EC2CapacityReservationsMetrics) {
+    /**
+     * Metrics for dimension set: CapacityReservation {CapacityReservationId}
+     *
+     * @stability external
+     */
+    class CapacityReservationMetrics {
+        dimensions;
+        constructor(props) {
+            this.dimensions = {
+                CapacityReservationId: props.capacityReservationId
+            };
+        }
+        /**
+         * Average of the InstanceUtilization metric
+         *
+         * @default - Average over 5 minutes
+         */
+        instanceUtilization(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2CapacityReservations",
+                metricName: "InstanceUtilization",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the UsedInstanceCount metric
+         *
+         * @default - Average over 5 minutes
+         */
+        usedInstanceCount(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2CapacityReservations",
+                metricName: "UsedInstanceCount",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the AvailableInstanceCount metric
+         *
+         * @default - Average over 5 minutes
+         */
+        availableInstanceCount(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2CapacityReservations",
+                metricName: "AvailableInstanceCount",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the TotalInstanceCount metric
+         *
+         * @default - Average over 5 minutes
+         */
+        totalInstanceCount(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2CapacityReservations",
+                metricName: "TotalInstanceCount",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+    }
+    EC2CapacityReservationsMetrics.CapacityReservationMetrics = CapacityReservationMetrics;
+})(EC2CapacityReservationsMetrics || (exports.EC2CapacityReservationsMetrics = EC2CapacityReservationsMetrics = {}));
+/**
+ * CloudWatch metrics facade for AWS/EBS
+ * This class contains helper functions to initialize the dimension-sets classes
+ * for selected resources if available.
+ *
+ * @stability external
+ */
+class EBSMetrics {
+    /**
+     * Create VolumeMetrics from a Volume reference
+     */
+    static fromVolume(ref) {
+        return new EBSMetrics.VolumeMetrics({
+            volumeId: ref.volumeRef.volumeId
+        });
+    }
+}
+exports.EBSMetrics = EBSMetrics;
+(function (EBSMetrics) {
+    /**
+     * Metrics for dimension set: Volume {VolumeId}
+     *
+     * @stability external
+     */
+    class VolumeMetrics {
+        dimensions;
+        constructor(props) {
+            this.dimensions = {
+                VolumeId: props.volumeId
+            };
+        }
+        /**
+         * Sum of the VolumeReadBytes metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        volumeReadBytes(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EBS",
+                metricName: "VolumeReadBytes",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the VolumeWriteBytes metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        volumeWriteBytes(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EBS",
+                metricName: "VolumeWriteBytes",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the VolumeReadOps metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        volumeReadOps(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EBS",
+                metricName: "VolumeReadOps",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Average of the VolumeTotalReadTime metric
+         *
+         * @default - Average over 5 minutes
+         */
+        volumeTotalReadTime(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EBS",
+                metricName: "VolumeTotalReadTime",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Sum of the VolumeWriteOps metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        volumeWriteOps(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EBS",
+                metricName: "VolumeWriteOps",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Average of the VolumeTotalWriteTime metric
+         *
+         * @default - Average over 5 minutes
+         */
+        volumeTotalWriteTime(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EBS",
+                metricName: "VolumeTotalWriteTime",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the VolumeIdleTime metric
+         *
+         * @default - Average over 5 minutes
+         */
+        volumeIdleTime(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EBS",
+                metricName: "VolumeIdleTime",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the VolumeQueueLength metric
+         *
+         * @default - Average over 5 minutes
+         */
+        volumeQueueLength(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EBS",
+                metricName: "VolumeQueueLength",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the BurstBalance metric
+         *
+         * @default - Average over 5 minutes
+         */
+        burstBalance(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EBS",
+                metricName: "BurstBalance",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+    }
+    EBSMetrics.VolumeMetrics = VolumeMetrics;
+})(EBSMetrics || (exports.EBSMetrics = EBSMetrics = {}));
+/**
+ * CloudWatch metrics facade for AWS/EC2
+ * This class contains helper functions to initialize the dimension-sets classes
+ * for selected resources if available.
+ *
+ * @stability external
+ */
+class EC2Metrics {
+    /**
+     * Create InstanceMetrics from a Instance reference
+     */
+    static fromInstance(ref) {
+        return new EC2Metrics.InstanceMetrics({
+            instanceId: ref.instanceRef.instanceId
+        });
+    }
+}
+exports.EC2Metrics = EC2Metrics;
+(function (EC2Metrics) {
+    /**
+     * Metrics for dimension set: Instance {InstanceId}
+     *
+     * @stability external
+     */
+    class InstanceMetrics {
+        dimensions;
+        constructor(props) {
+            this.dimensions = {
+                InstanceId: props.instanceId
+            };
+        }
+        /**
+         * Average of the CPUCreditUsage metric
+         *
+         * @default - Average over 5 minutes
+         */
+        cpuCreditUsage(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "CPUCreditUsage",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the CPUCreditBalance metric
+         *
+         * @default - Average over 5 minutes
+         */
+        cpuCreditBalance(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "CPUCreditBalance",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the CPUSurplusCreditBalance metric
+         *
+         * @default - Average over 5 minutes
+         */
+        cpuSurplusCreditBalance(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "CPUSurplusCreditBalance",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the CPUSurplusCreditsCharged metric
+         *
+         * @default - Average over 5 minutes
+         */
+        cpuSurplusCreditsCharged(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "CPUSurplusCreditsCharged",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the CPUUtilization metric
+         *
+         * @default - Average over 5 minutes
+         */
+        cpuUtilization(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "CPUUtilization",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the DiskReadBytes metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskReadBytes(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "DiskReadBytes",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the DiskReadOps metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskReadOps(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "DiskReadOps",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the DiskWriteBytes metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskWriteBytes(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "DiskWriteBytes",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the DiskWriteOps metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskWriteOps(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "DiskWriteOps",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Sum of the MetadataNoToken metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        metadataNoToken(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "MetadataNoToken",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Average of the NetworkIn metric
+         *
+         * @default - Average over 5 minutes
+         */
+        networkIn(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "NetworkIn",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the NetworkOut metric
+         *
+         * @default - Average over 5 minutes
+         */
+        networkOut(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "NetworkOut",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the NetworkPacketsIn metric
+         *
+         * @default - Average over 5 minutes
+         */
+        networkPacketsIn(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "NetworkPacketsIn",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the NetworkPacketsOut metric
+         *
+         * @default - Average over 5 minutes
+         */
+        networkPacketsOut(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "NetworkPacketsOut",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Sum of the StatusCheckFailed metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        statusCheckFailed(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "StatusCheckFailed",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the StatusCheckFailed_Instance metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        statusCheckFailedInstance(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "StatusCheckFailed_Instance",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the StatusCheckFailed_System metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        statusCheckFailedSystem(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "StatusCheckFailed_System",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Average of the EBSReadOps metric
+         *
+         * @default - Average over 5 minutes
+         */
+        ebsReadOps(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "EBSReadOps",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the EBSWriteOps metric
+         *
+         * @default - Average over 5 minutes
+         */
+        ebsWriteOps(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "EBSWriteOps",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the EBSReadBytes metric
+         *
+         * @default - Average over 5 minutes
+         */
+        ebsReadBytes(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "EBSReadBytes",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the EBSWriteBytes metric
+         *
+         * @default - Average over 5 minutes
+         */
+        ebsWriteBytes(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "EBSWriteBytes",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the EBSIOBalance% metric
+         *
+         * @default - Average over 5 minutes
+         */
+        ebsioBalance(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "EBSIOBalance%",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the EBSByteBalance% metric
+         *
+         * @default - Average over 5 minutes
+         */
+        ebsByteBalance(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "EBSByteBalance%",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+    }
+    EC2Metrics.InstanceMetrics = InstanceMetrics;
+    /**
+     * Metrics for dimension set: Account {no dimensions}
+     *
+     * @stability external
+     */
+    class AccountMetrics {
+        dimensions;
+        constructor() {
+            this.dimensions = {};
+        }
+        /**
+         * Average of the CPUUtilization metric
+         *
+         * @default - Average over 5 minutes
+         */
+        cpuUtilization(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "CPUUtilization",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the DiskReadBytes metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskReadBytes(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "DiskReadBytes",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the DiskReadOps metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskReadOps(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "DiskReadOps",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the DiskWriteBytes metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskWriteBytes(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "DiskWriteBytes",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the DiskWriteOps metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskWriteOps(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "DiskWriteOps",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Sum of the MetadataNoToken metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        metadataNoToken(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "MetadataNoToken",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Average of the NetworkIn metric
+         *
+         * @default - Average over 5 minutes
+         */
+        networkIn(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "NetworkIn",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the NetworkOut metric
+         *
+         * @default - Average over 5 minutes
+         */
+        networkOut(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "NetworkOut",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the NetworkPacketsIn metric
+         *
+         * @default - Average over 5 minutes
+         */
+        networkPacketsIn(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "NetworkPacketsIn",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the NetworkPacketsOut metric
+         *
+         * @default - Average over 5 minutes
+         */
+        networkPacketsOut(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "NetworkPacketsOut",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+    }
+    EC2Metrics.AccountMetrics = AccountMetrics;
+    /**
+     * Metrics for dimension set: AutoScalingGroup {AutoScalingGroupName}
+     *
+     * @stability external
+     */
+    class AutoScalingGroupMetrics {
+        dimensions;
+        constructor(props) {
+            this.dimensions = {
+                AutoScalingGroupName: props.autoScalingGroupName
+            };
+        }
+        /**
+         * Average of the CPUUtilization metric
+         *
+         * @default - Average over 5 minutes
+         */
+        cpuUtilization(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "CPUUtilization",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the DiskReadBytes metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskReadBytes(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "DiskReadBytes",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the DiskReadOps metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskReadOps(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "DiskReadOps",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the DiskWriteBytes metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskWriteBytes(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "DiskWriteBytes",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the DiskWriteOps metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskWriteOps(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "DiskWriteOps",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the NetworkIn metric
+         *
+         * @default - Average over 5 minutes
+         */
+        networkIn(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "NetworkIn",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the NetworkOut metric
+         *
+         * @default - Average over 5 minutes
+         */
+        networkOut(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "NetworkOut",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the NetworkPacketsIn metric
+         *
+         * @default - Average over 5 minutes
+         */
+        networkPacketsIn(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "NetworkPacketsIn",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the NetworkPacketsOut metric
+         *
+         * @default - Average over 5 minutes
+         */
+        networkPacketsOut(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "NetworkPacketsOut",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+    }
+    EC2Metrics.AutoScalingGroupMetrics = AutoScalingGroupMetrics;
+    /**
+     * Metrics for dimension set: Image {ImageId}
+     *
+     * @stability external
+     */
+    class ImageMetrics {
+        dimensions;
+        constructor(props) {
+            this.dimensions = {
+                ImageId: props.imageId
+            };
+        }
+        /**
+         * Average of the CPUUtilization metric
+         *
+         * @default - Average over 5 minutes
+         */
+        cpuUtilization(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "CPUUtilization",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the DiskReadBytes metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskReadBytes(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "DiskReadBytes",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the DiskReadOps metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskReadOps(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "DiskReadOps",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the DiskWriteBytes metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskWriteBytes(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "DiskWriteBytes",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the DiskWriteOps metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskWriteOps(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "DiskWriteOps",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the NetworkIn metric
+         *
+         * @default - Average over 5 minutes
+         */
+        networkIn(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "NetworkIn",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the NetworkOut metric
+         *
+         * @default - Average over 5 minutes
+         */
+        networkOut(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "NetworkOut",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+    }
+    EC2Metrics.ImageMetrics = ImageMetrics;
+    /**
+     * Metrics for dimension set: InstanceType {InstanceType}
+     *
+     * @stability external
+     */
+    class InstanceTypeMetrics {
+        dimensions;
+        constructor(props) {
+            this.dimensions = {
+                InstanceType: props.instanceType
+            };
+        }
+        /**
+         * Average of the CPUUtilization metric
+         *
+         * @default - Average over 5 minutes
+         */
+        cpuUtilization(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "CPUUtilization",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the DiskReadBytes metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskReadBytes(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "DiskReadBytes",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the DiskReadOps metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskReadOps(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "DiskReadOps",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the DiskWriteBytes metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskWriteBytes(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "DiskWriteBytes",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the DiskWriteOps metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskWriteOps(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "DiskWriteOps",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the NetworkIn metric
+         *
+         * @default - Average over 5 minutes
+         */
+        networkIn(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "NetworkIn",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the NetworkOut metric
+         *
+         * @default - Average over 5 minutes
+         */
+        networkOut(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/EC2",
+                metricName: "NetworkOut",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+    }
+    EC2Metrics.InstanceTypeMetrics = InstanceTypeMetrics;
+})(EC2Metrics || (exports.EC2Metrics = EC2Metrics = {}));
+/**
+ * CloudWatch metrics facade for CWAgent
+ * This class contains helper functions to initialize the dimension-sets classes
+ * for selected resources if available.
+ *
+ * @stability external
+ */
+class CWAgentMetrics {
+}
+exports.CWAgentMetrics = CWAgentMetrics;
+(function (CWAgentMetrics) {
+    /**
+     * Metrics for dimension set: Instance {InstanceId}
+     *
+     * @stability external
+     */
+    class InstanceMetrics {
+        dimensions;
+        constructor(props) {
+            this.dimensions = {
+                InstanceId: props.instanceId
+            };
+        }
+        /**
+         * Average of the cpu_usage_idle metric
+         *
+         * @default - Average over 5 minutes
+         */
+        cpuUsageIdle(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "cpu_usage_idle",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the cpu_usage_iowait metric
+         *
+         * @default - Average over 5 minutes
+         */
+        cpuUsageIowait(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "cpu_usage_iowait",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the cpu_usage_steal metric
+         *
+         * @default - Average over 5 minutes
+         */
+        cpuUsageSteal(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "cpu_usage_steal",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the cpu_usage_system metric
+         *
+         * @default - Average over 5 minutes
+         */
+        cpuUsageSystem(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "cpu_usage_system",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the cpu_usage_user metric
+         *
+         * @default - Average over 5 minutes
+         */
+        cpuUsageUser(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "cpu_usage_user",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Sum of the disk_inodes_free metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        diskInodesFree(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "disk_inodes_free",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the disk_inodes_total metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        diskInodesTotal(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "disk_inodes_total",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the disk_inodes_used metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        diskInodesUsed(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "disk_inodes_used",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Maximum of the disk_used_percent metric
+         *
+         * @default - Maximum over 5 minutes
+         */
+        diskUsedPercent(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "disk_used_percent",
+                dimensionsMap: this.dimensions,
+                statistic: "Maximum",
+                ...options
+            });
+        }
+        /**
+         * Maximum of the disk_used metric
+         *
+         * @default - Maximum over 5 minutes
+         */
+        diskUsed(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "disk_used",
+                dimensionsMap: this.dimensions,
+                statistic: "Maximum",
+                ...options
+            });
+        }
+        /**
+         * Maximum of the disk_total metric
+         *
+         * @default - Maximum over 5 minutes
+         */
+        diskTotal(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "disk_total",
+                dimensionsMap: this.dimensions,
+                statistic: "Maximum",
+                ...options
+            });
+        }
+        /**
+         * Average of the diskio_io_time metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskioIoTime(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "diskio_io_time",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the diskio_read_bytes metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskioReadBytes(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "diskio_read_bytes",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the diskio_reads metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskioReads(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "diskio_reads",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the diskio_write_bytes metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskioWriteBytes(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "diskio_write_bytes",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the diskio_writes metric
+         *
+         * @default - Average over 5 minutes
+         */
+        diskioWrites(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "diskio_writes",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the mem_cached metric
+         *
+         * @default - Average over 5 minutes
+         */
+        memCached(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "mem_cached",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the mem_total metric
+         *
+         * @default - Average over 5 minutes
+         */
+        memTotal(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "mem_total",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the mem_used metric
+         *
+         * @default - Average over 5 minutes
+         */
+        memUsed(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "mem_used",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the mem_used_percent metric
+         *
+         * @default - Average over 5 minutes
+         */
+        memUsedPercent(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "mem_used_percent",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Sum of the netstat_tcp_established metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        netstatTcpEstablished(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "netstat_tcp_established",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the netstat_tcp_time_wait metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        netstatTcpTimeWait(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "netstat_tcp_time_wait",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Average of the swap_used_percent metric
+         *
+         * @default - Average over 5 minutes
+         */
+        swapUsedPercent(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "swap_used_percent",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Sum of the ethtool_bw_in_allowance_exceeded metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        ethtoolBwInAllowanceExceeded(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "ethtool_bw_in_allowance_exceeded",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the ethtool_bw_out_allowance_exceeded metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        ethtoolBwOutAllowanceExceeded(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "ethtool_bw_out_allowance_exceeded",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Average of the ethtool_conntrack_allowance_available metric
+         *
+         * @default - Average over 5 minutes
+         */
+        ethtoolConntrackAllowanceAvailable(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "ethtool_conntrack_allowance_available",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the ethtool_ena_srd_mode metric
+         *
+         * @default - Average over 5 minutes
+         */
+        ethtoolEnaSrdMode(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "ethtool_ena_srd_mode",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Sum of the ethtool_ena_srd_eligible_tx_pkts metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        ethtoolEnaSrdEligibleTxPkts(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "ethtool_ena_srd_eligible_tx_pkts",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the ethtool_ena_srd_tx_pkts metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        ethtoolEnaSrdTxPkts(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "ethtool_ena_srd_tx_pkts",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the ethtool_ena_srd_rx_pkts metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        ethtoolEnaSrdRxPkts(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "ethtool_ena_srd_rx_pkts",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Average of the ethtool_ena_srd_resource_utilization metric
+         *
+         * @default - Average over 5 minutes
+         */
+        ethtoolEnaSrdResourceUtilization(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "ethtool_ena_srd_resource_utilization",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Sum of the ethtool_linklocal_allowance_exceeded metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        ethtoolLinklocalAllowanceExceeded(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "ethtool_linklocal_allowance_exceeded",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the ethtool_pps_allowance_exceeded metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        ethtoolPpsAllowanceExceeded(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "ethtool_pps_allowance_exceeded",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the ethtool_conntrack_allowance_exceeded metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        ethtoolConntrackAllowanceExceeded(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "ethtool_conntrack_allowance_exceeded",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the TCPv4 Connections Established metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        tcPv4ConnectionsEstablished(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "TCPv4 Connections Established",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the TCPv6 Connections Established metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        tcPv6ConnectionsEstablished(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "TCPv6 Connections Established",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Average of the Memory % Committed Bytes In Use metric
+         *
+         * @default - Average over 5 minutes
+         */
+        memoryCommittedBytesInUse(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "Memory % Committed Bytes In Use",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the Processor % Idle Time metric
+         *
+         * @default - Average over 5 minutes
+         */
+        processorIdleTime(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "Processor % Idle Time",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the Processor % Interrupt Time metric
+         *
+         * @default - Average over 5 minutes
+         */
+        processorInterruptTime(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "Processor % Interrupt Time",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the Processor % User Time metric
+         *
+         * @default - Average over 5 minutes
+         */
+        processorUserTime(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "Processor % User Time",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the LogicalDisk % Free Space metric
+         *
+         * @default - Average over 5 minutes
+         */
+        logicalDiskFreeSpace(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "LogicalDisk % Free Space",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the Paging File % Usage metric
+         *
+         * @default - Average over 5 minutes
+         */
+        pagingFileUsage(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "Paging File % Usage",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the PhysicalDisk % Disk Time metric
+         *
+         * @default - Average over 5 minutes
+         */
+        physicalDiskDiskTime(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "PhysicalDisk % Disk Time",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the PhysicalDisk Disk Read Bytes/sec metric
+         *
+         * @default - Average over 5 minutes
+         */
+        physicalDiskDiskReadBytesSec(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "PhysicalDisk Disk Read Bytes/sec",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the PhysicalDisk Disk Write Bytes/sec metric
+         *
+         * @default - Average over 5 minutes
+         */
+        physicalDiskDiskWriteBytesSec(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "PhysicalDisk Disk Write Bytes/sec",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the PhysicalDisk Disk Writes/sec metric
+         *
+         * @default - Average over 5 minutes
+         */
+        physicalDiskDiskWritesSec(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "PhysicalDisk Disk Writes/sec",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the PhysicalDisk Disk Reads/sec metric
+         *
+         * @default - Average over 5 minutes
+         */
+        physicalDiskDiskReadsSec(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "PhysicalDisk Disk Reads/sec",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Sum of the Aggregate inbound BW allowance exceeded metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        aggregateInboundBwAllowanceExceeded(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "Aggregate inbound BW allowance exceeded",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the Aggregate outbound BW allowance exceeded metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        aggregateOutboundBwAllowanceExceeded(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "Aggregate outbound BW allowance exceeded",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Average of the Available connection tracking allowance metric
+         *
+         * @default - Average over 5 minutes
+         */
+        availableConnectionTrackingAllowance(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "Available connection tracking allowance",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Average of the ena srd mode metric
+         *
+         * @default - Average over 5 minutes
+         */
+        enaSrdMode(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "ena srd mode",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Sum of the ena srd eligible tx pkts metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        enaSrdEligibleTxPkts(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "ena srd eligible tx pkts",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the ena srd tx pkts metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        enaSrdTxPkts(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "ena srd tx pkts",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the ena srd rx pkts metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        enaSrdRxPkts(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "ena srd rx pkts",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Average of the ena srd resource utilization metric
+         *
+         * @default - Average over 5 minutes
+         */
+        enaSrdResourceUtilization(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "ena srd resource utilization",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Sum of the Link local packet rate allowance exceeded metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        linkLocalPacketRateAllowanceExceeded(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "Link local packet rate allowance exceeded",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the PPS allowance exceeded metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        ppsAllowanceExceeded(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "PPS allowance exceeded",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the Connection tracking allowance exceeded metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        connectionTrackingAllowanceExceeded(options) {
+            return new cloudwatch.Metric({
+                namespace: "CWAgent",
+                metricName: "Connection tracking allowance exceeded",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+    }
+    CWAgentMetrics.InstanceMetrics = InstanceMetrics;
+})(CWAgentMetrics || (exports.CWAgentMetrics = CWAgentMetrics = {}));
+/**
+ * CloudWatch metrics facade for AWS/NATGateway
+ * This class contains helper functions to initialize the dimension-sets classes
+ * for selected resources if available.
+ *
+ * @stability external
+ */
+class NATGatewayMetrics {
+    /**
+     * Create NatGatewayMetrics from a NatGateway reference
+     */
+    static fromNatGateway(ref) {
+        return new NATGatewayMetrics.NatGatewayMetrics({
+            natGatewayId: ref.natGatewayRef.natGatewayId
+        });
+    }
+}
+exports.NATGatewayMetrics = NATGatewayMetrics;
+(function (NATGatewayMetrics) {
+    /**
+     * Metrics for dimension set: NatGateway {NatGatewayId}
+     *
+     * @stability external
+     */
+    class NatGatewayMetrics {
+        dimensions;
+        constructor(props) {
+            this.dimensions = {
+                NatGatewayId: props.natGatewayId
+            };
+        }
+        /**
+         * Maximum of the ActiveConnectionCount metric
+         *
+         * @default - Maximum over 5 minutes
+         */
+        activeConnectionCount(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/NATGateway",
+                metricName: "ActiveConnectionCount",
+                dimensionsMap: this.dimensions,
+                statistic: "Maximum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the PacketsDropCount metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        packetsDropCount(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/NATGateway",
+                metricName: "PacketsDropCount",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the BytesInFromDestination metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        bytesInFromDestination(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/NATGateway",
+                metricName: "BytesInFromDestination",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the BytesInFromSource metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        bytesInFromSource(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/NATGateway",
+                metricName: "BytesInFromSource",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the BytesOutToDestination metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        bytesOutToDestination(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/NATGateway",
+                metricName: "BytesOutToDestination",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the BytesOutToSource metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        bytesOutToSource(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/NATGateway",
+                metricName: "BytesOutToSource",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the ConnectionAttemptCount metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        connectionAttemptCount(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/NATGateway",
+                metricName: "ConnectionAttemptCount",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the ConnectionEstablishedCount metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        connectionEstablishedCount(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/NATGateway",
+                metricName: "ConnectionEstablishedCount",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the ErrorPortAllocation metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        errorPortAllocation(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/NATGateway",
+                metricName: "ErrorPortAllocation",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the IdleTimeoutCount metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        idleTimeoutCount(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/NATGateway",
+                metricName: "IdleTimeoutCount",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the PacketsInFromDestination metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        packetsInFromDestination(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/NATGateway",
+                metricName: "PacketsInFromDestination",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the PacketsInFromSource metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        packetsInFromSource(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/NATGateway",
+                metricName: "PacketsInFromSource",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the PacketsOutToDestination metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        packetsOutToDestination(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/NATGateway",
+                metricName: "PacketsOutToDestination",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the PacketsOutToSource metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        packetsOutToSource(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/NATGateway",
+                metricName: "PacketsOutToSource",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Maximum of the PeakBytesPerSecond metric
+         *
+         * @default - Maximum over 5 minutes
+         */
+        peakBytesPerSecond(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/NATGateway",
+                metricName: "PeakBytesPerSecond",
+                dimensionsMap: this.dimensions,
+                statistic: "Maximum",
+                ...options
+            });
+        }
+        /**
+         * Maximum of the PeakPacketsPerSecond metric
+         *
+         * @default - Maximum over 5 minutes
+         */
+        peakPacketsPerSecond(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/NATGateway",
+                metricName: "PeakPacketsPerSecond",
+                dimensionsMap: this.dimensions,
+                statistic: "Maximum",
+                ...options
+            });
+        }
+    }
+    NATGatewayMetrics.NatGatewayMetrics = NatGatewayMetrics;
+})(NATGatewayMetrics || (exports.NATGatewayMetrics = NATGatewayMetrics = {}));
+/**
+ * CloudWatch metrics facade for AWS/TransitGateway
+ * This class contains helper functions to initialize the dimension-sets classes
+ * for selected resources if available.
+ *
+ * @stability external
+ */
+class TransitGatewayMetrics {
+}
+exports.TransitGatewayMetrics = TransitGatewayMetrics;
+(function (TransitGatewayMetrics_1) {
+    /**
+     * Metrics for dimension set: TransitGateway {TransitGateway}
+     *
+     * @stability external
+     */
+    class TransitGatewayMetrics {
+        dimensions;
+        constructor(props) {
+            this.dimensions = {
+                TransitGateway: props.transitGateway
+            };
+        }
+        /**
+         * Sum of the BytesIn metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        bytesIn(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/TransitGateway",
+                metricName: "BytesIn",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the BytesOut metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        bytesOut(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/TransitGateway",
+                metricName: "BytesOut",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the PacketDropCountBlackhole metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        packetDropCountBlackhole(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/TransitGateway",
+                metricName: "PacketDropCountBlackhole",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the PacketDropCountNoRoute metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        packetDropCountNoRoute(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/TransitGateway",
+                metricName: "PacketDropCountNoRoute",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the PacketsIn metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        packetsIn(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/TransitGateway",
+                metricName: "PacketsIn",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Sum of the PacketsOut metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        packetsOut(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/TransitGateway",
+                metricName: "PacketsOut",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+    }
+    TransitGatewayMetrics_1.TransitGatewayMetrics = TransitGatewayMetrics;
+})(TransitGatewayMetrics || (exports.TransitGatewayMetrics = TransitGatewayMetrics = {}));
+/**
+ * CloudWatch metrics facade for AWS/VPN
+ * This class contains helper functions to initialize the dimension-sets classes
+ * for selected resources if available.
+ *
+ * @stability external
+ */
+class VPNMetrics {
+}
+exports.VPNMetrics = VPNMetrics;
+(function (VPNMetrics) {
+    /**
+     * Metrics for dimension set: VpnConnection {VpnId}
+     *
+     * @stability external
+     */
+    class VpnConnectionMetrics {
+        dimensions;
+        constructor(props) {
+            this.dimensions = {
+                VpnId: props.vpnId
+            };
+        }
+        /**
+         * Sum of the TunnelDataIn metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        tunnelDataIn(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/VPN",
+                metricName: "TunnelDataIn",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+        /**
+         * Average of the TunnelState metric
+         *
+         * @default - Average over 5 minutes
+         */
+        tunnelState(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/VPN",
+                metricName: "TunnelState",
+                dimensionsMap: this.dimensions,
+                statistic: "Average",
+                ...options
+            });
+        }
+        /**
+         * Sum of the TunnelDataOut metric
+         *
+         * @default - Sum over 5 minutes
+         */
+        tunnelDataOut(options) {
+            return new cloudwatch.Metric({
+                namespace: "AWS/VPN",
+                metricName: "TunnelDataOut",
+                dimensionsMap: this.dimensions,
+                statistic: "Sum",
+                ...options
+            });
+        }
+    }
+    VPNMetrics.VpnConnectionMetrics = VpnConnectionMetrics;
+})(VPNMetrics || (exports.VPNMetrics = VPNMetrics = {}));